From 9b759b85d200c66541d98f6693beb19c5834a1f3 Mon Sep 17 00:00:00 2001
From: Deadintegral
Date: Thu, 25 Jan 2024 23:25:32 +0900
Subject: [PATCH 01/16] docs: translate what is a webhook
---
translations/README-kr.md | 1740 +++++++++++++++++++++++++++++++++++++
1 file changed, 1740 insertions(+)
create mode 100644 translations/README-kr.md
diff --git a/translations/README-kr.md b/translations/README-kr.md
new file mode 100644
index 0000000..5df8f36
--- /dev/null
+++ b/translations/README-kr.md
@@ -0,0 +1,1740 @@
+
+
+
+
+
+ ใ
+
+ ๐จ๐ปโ๐ป YouTube
+ |
+
+ ๐ฎ Newsletter
+ ใ
+
+
+
+
+# System Design 101
+
+์๊ฐ ์๋ฃ์ ๊ฐ๋จํ ์ฉ์ด๋ฅผ ์ฌ์ฉํ์ฌ ๋ณต์กํ ์์คํ
์ ์ค๋ช
ํฉ๋๋ค.
+
+Whether you're preparing for a System Design Interview or you simply want to understand how systems work beneath the surface, we hope this repository will help you achieve that.
+์์คํ
๋์์ธ ๋ฉด์ ์ ์ค๋น ์ค์ด๊ฑฐ๋ ๋จ์ํ ์์คํ
์ด ํ๋ฉด ์๋์์ ์ด๋ป๊ฒ ์๋ํ๋์ง ์ดํดํ๊ณ ์ถ์ผ์ ๋ถ์ด๋ผ๋ฉด ์ด ๋ฆฌํฌ์งํ ๋ฆฌ๊ฐ ๋์์ด ๋๊ธธ ๋ฐ๋๋๋ค.
+
+# Table of Contents
+
+
+
+- [Communication protocols](#communication-protocols)
+ - [REST API vs. GraphQL](#rest-api-vs-graphql)
+ - [gRPC๋ ์ด๋ป๊ฒ ์๋ํ๋์?](#how-does-grpc-work)
+ - [webhook์ด๋ ๋ฌด์์ธ๊ฐ์?](#what-is-a-webhook)
+ - [API ์ฑ๋ฅ์ ๊ฐ์ ํ๋ ๋ฐฉ๋ฒ์ ๋ฌด์์ธ๊ฐ์?](#how-to-improve-api-performance)
+ - [HTTP 1.0 -\> HTTP 1.1 -\> HTTP 2.0 -\> HTTP 3.0 (QUIC)](#http-10---http-11---http-20---http-30-quic)
+ - [SOAP vs REST vs GraphQL vs RPC](#soap-vs-rest-vs-graphql-vs-rpc)
+ - [Code First vs. API First](#code-first-vs-api-first)
+ - [HTTP status codes](#http-status-codes)
+ - [API gateway๋ ๋ฌด์์ ํ๋์?](#what-does-api-gateway-do)
+ - [ํจ๊ณผ์ ์ด๊ณ ์์ ํ API๋ฅผ ์ค๊ณํ๋ ค๋ฉด ์ด๋ป๊ฒ ํด์ผ ํ ๊น์?](#how-do-we-design-effective-and-safe-apis)
+ - [TCP/IP encapsulation](#tcpip-encapsulation)
+ - [์ Nginx๋ฅผ "reverse" ํ๋ก์๋ผ๊ณ ๋ถ๋ฅด๋์?](#why-is-nginx-called-a-reverse-proxy)
+ - [์ผ๋ฐ์ ์ธ ๋ก๋ ๋ฐธ๋ฐ์ฑ ์๊ณ ๋ฆฌ์ฆ์ ๋ฌด์์ธ๊ฐ์?](#what-are-the-common-load-balancing-algorithms)
+ - [URL, URI, URN - ์ฐจ์ด๋ฅผ ์๊ณ ์๋์?](#url-uri-urn---do-you-know-the-differences)
+- [CI/CD](#cicd)
+ - [์ฌ์ด ์ฉ์ด๋ก ์ค๋ช
ํ๋ CI/CD ํ์ดํ๋ผ์ธ](#cicd-pipeline-explained-in-simple-terms)
+ - [๋ทํ๋ฆญ์ค ํ
ํฌ ์คํ (CI/CD Pipeline)](#netflix-tech-stack-cicd-pipeline)
+- [์ํคํ
์ฒ ํจํด](#architecture-patterns)
+ - [MVC, MVP, MVVM, MVVM-C, and VIPER](#mvc-mvp-mvvm-mvvm-c-and-viper)
+ - [18 Key Design Patterns Every Developer Should Know](#18-key-design-patterns-every-developer-should-know)
+- [Database](#database)
+ - [A nice cheat sheet of different databases in cloud services](#a-nice-cheat-sheet-of-different-databases-in-cloud-services)
+ - [8 Data Structures That Power Your Databases](#8-data-structures-that-power-your-databases)
+ - [How is an SQL statement executed in the database?](#how-is-an-sql-statement-executed-in-the-database)
+ - [CAP theorem](#cap-theorem)
+ - [Types of Memory and Storage](#types-of-memory-and-storage)
+ - [Visualizing a SQL query](#visualizing-a-sql-query)
+ - [SQL language](#sql-language)
+- [Cache](#cache)
+ - [Data is cached everywhere](#data-is-cached-everywhere)
+ - [Why is Redis so fast?](#why-is-redis-so-fast)
+ - [How can Redis be used?](#how-can-redis-be-used)
+ - [Top caching strategies](#top-caching-strategies)
+- [Microservice architecture](#microservice-architecture)
+ - [What does a typical microservice architecture look like?](#what-does-a-typical-microservice-architecture-look-like)
+ - [Microservice Best Practices](#microservice-best-practices)
+ - [What tech stack is commonly used for microservices?](#what-tech-stack-is-commonly-used-for-microservices)
+ - [Why is Kafka fast](#why-is-kafka-fast)
+- [Payment systems](#payment-systems)
+ - [How to learn payment systems?](#how-to-learn-payment-systems)
+ - [Why is the credit card called โthe most profitable product in banksโ? How does VISA/Mastercard make money?](#why-is-the-credit-card-called-the-most-profitable-product-in-banks-how-does-visamastercard-make-money)
+ - [How does VISA work when we swipe a credit card at a merchantโs shop?](#how-does-visa-work-when-we-swipe-a-credit-card-at-a-merchants-shop)
+ - [Payment Systems Around The World Series (Part 1): Unified Payments Interface (UPI) in India](#payment-systems-around-the-world-series-part-1-unified-payments-interface-upi-in-india)
+- [DevOps](#devops)
+ - [DevOps vs. SRE vs. Platform Engineering. What is the difference?](#devops-vs-sre-vs-platform-engineering-what-is-the-difference)
+ - [What is k8s (Kubernetes)?](#what-is-k8s-kubernetes)
+ - [Docker vs. Kubernetes. Which one should we use?](#docker-vs-kubernetes-which-one-should-we-use)
+ - [How does Docker work?](#how-does-docker-work)
+- [GIT](#git)
+ - [How Git Commands work](#how-git-commands-work)
+ - [How does Git Work?](#how-does-git-work)
+ - [Git merge vs. Git rebase](#git-merge-vs-git-rebase)
+- [Cloud Services](#cloud-services)
+ - [A nice cheat sheet of different cloud services (2023 edition)](#a-nice-cheat-sheet-of-different-cloud-services-2023-edition)
+ - [What is cloud native?](#what-is-cloud-native)
+- [Developer productivity tools](#developer-productivity-tools)
+ - [Visualize JSON files](#visualize-json-files)
+ - [Automatically turn code into architecture diagrams](#automatically-turn-code-into-architecture-diagrams)
+- [Linux](#linux)
+ - [Linux file system explained](#linux-file-system-explained)
+ - [18 Most-used Linux Commands You Should Know](#18-most-used-linux-commands-you-should-know)
+- [Security](#security)
+ - [How does HTTPS work?](#how-does-https-work)
+ - [Oauth 2.0 Explained With Simple Terms.](#oauth-20-explained-with-simple-terms)
+ - [Top 4 Forms of Authentication Mechanisms](#top-4-forms-of-authentication-mechanisms)
+ - [Session, cookie, JWT, token, SSO, and OAuth 2.0 - what are they?](#session-cookie-jwt-token-sso-and-oauth-20---what-are-they)
+ - [How to store passwords safely in the database and how to validate a password?](#how-to-store-passwords-safely-in-the-database-and-how-to-validate-a-password)
+ - [Explaining JSON Web Token (JWT) to a 10 year old Kid](#explaining-json-web-token-jwt-to-a-10-year-old-kid)
+ - [How does Google Authenticator (or other types of 2-factor authenticators) work?](#how-does-google-authenticator-or-other-types-of-2-factor-authenticators-work)
+- [Real World Case Studies](#real-world-case-studies)
+ - [Netflix's Tech Stack](#netflixs-tech-stack)
+ - [Twitter Architecture 2022](#twitter-architecture-2022)
+ - [Evolution of Airbnbโs microservice architecture over the past 15 years](#evolution-of-airbnbs-microservice-architecture-over-the-past-15-years)
+ - [Monorepo vs. Microrepo.](#monorepo-vs-microrepo)
+ - [How will you design the Stack Overflow website?](#how-will-you-design-the-stack-overflow-website)
+ - [Why did Amazon Prime Video monitoring move from serverless to monolithic? How can it save 90% cost?](#why-did-amazon-prime-video-monitoring-move-from-serverless-to-monolithic-how-can-it-save-90-cost)
+ - [How does Disney Hotstar capture 5 Billion Emojis during a tournament?](#how-does-disney-hotstar-capture-5-billion-emojis-during-a-tournament)
+ - [How Discord Stores Trillions Of Messages](#how-discord-stores-trillions-of-messages)
+ - [How do video live streamings work on YouTube, TikTok live, or Twitch?](#how-do-video-live-streamings-work-on-youtube-tiktok-live-or-twitch)
+
+
+
+## Communication protocols
+
+์ํคํ
์ฒ ์คํ์ผ์ ์ ํ๋ฆฌ์ผ์ด์
ํ๋ก๊ทธ๋๋ฐ ์ธํฐํ์ด์ค(API)์ ์ฌ๋ฌ ๊ตฌ์ฑ ์์๊ฐ ์๋ก ์ํธ ์์ฉํ๋ ๋ฐฉ์์ ์ ์ํฉ๋๋ค. ๊ฒฐ๊ณผ์ ์ผ๋ก API๋ฅผ ์ค๊ณํ๊ณ ๊ตฌ์ถํ๋ ํ์ค ์ ๊ทผ ๋ฐฉ์์ ์ ๊ณตํจ์ผ๋ก์จ ํจ์จ์ฑ, ์์ ์ฑ, ๋ค๋ฅธ ์์คํ
๊ณผ์ ์ฌ์ด ํตํฉ์ ๋ณด์ฅํฉ๋๋ค. ๋ค์์ ๊ฐ์ฅ ๋ง์ด ์ฌ์ฉ๋๋ ์คํ์ผ์
๋๋ค.
+
+
+
+
+
+- SOAP:ย
+
+ ์ฑ์ํ๊ณ , ํฌ๊ด์ ์ด๊ณ , XML ๊ธฐ๋ฐ
+
+ ์ํฐํ๋ผ์ด์ฆ ์ ํ๋ฆฌ์ผ์ด์
์ ๊ฐ์ฅ ์ ํฉ
+
+- RESTful:ย
+
+ ์ธ๊ธฐ์๊ณ , ๊ตฌํํ๊ธฐ ์ฝ๊ณ , HTTP methodsย
+
+ ์น ์๋น์ค์ ์ด์์ ย
+
+- GraphQL:ย
+
+ ์ฟผ๋ฆฌ ์ธ์ด, ํน์ ๋ฐ์ดํฐ ์์ฒญย
+
+ ๋คํธ์ํฌ ์ค๋ฒํค๋ ๊ฐ์, ๋น ๋ฅธ ์๋ต
+
+- gRPC:ย
+
+ Modern, high-performance, Protocol Buffersย
+
+ ๋ง์ดํฌ๋ก ์๋น์ค ์ํคํ
์ฒ์ ์ ํฉ
+
+- WebSocket:ย
+
+ ์ค์๊ฐ, ์๋ฐฉํฅ, ์ง์์ ์ธ ์ฐ๊ฒฐ
+
+ ์ง์ฐ ์๊ฐ์ด ์งง์ ๋ฐ์ดํฐ์ ์ ํฉ
+
+- Webhook:ย
+
+ ์ด๋ฒคํธ ๊ธฐ๋ฐ, HTTP ์ฝ๋ฐฑ, ๋น๋๊ธฐ์ย
+
+ ์ด๋ฒคํธ๊ฐ ๋ฐ์ํ๋ฉด ์์คํ
์ ์๋ฆผ
+
+
+### REST API vs. GraphQL
+
+API ์ค๊ณ์ ์์ด์ REST์ GraphQL์ ๊ณ ์ ์ ์ฅ๋จ์ ์ด ์์ต๋๋ค.
+
+์๋ ๋ค์ด์ด๊ทธ๋จ์ REST์ GraphQL์ ๊ฐ๋ตํ๊ฒ ๋น๊ตํ ๊ฒ์
๋๋ค.
+
+
+
+
+
+REST
+
+- CRUD ์์
์ GET, POST, PUT, DELETE์ ๊ฐ์ ํ์ค HTTP ๋ฉ์๋๋ฅผ ์ฌ์ฉํฉ๋๋ค.
+- ์๋ก ๋ค๋ฅธ ์๋น์ค/์ ํ๋ฆฌ์ผ์ด์
๊ฐ์ ๊ฐ๋จํ๊ณ ๊ท ์ผํ ์ธํฐํ์ด์ค๊ฐ ํ์ํ ๋ ํจ๊ณผ์ ์
๋๋ค.
+- ์บ์ฑ ์ ๋ต์ ๊ตฌํ์ด ๊ฐ๋จํฉ๋๋ค.
+- ๋จ์ ์ผ๋ก ๋ณ๋์ ์๋ํฌ์ธํธ์์ ๊ด๋ จ ๋ฐ์ดํฐ๋ฅผ ์์งํ๊ธฐ ์ํด ์ฌ๋ฌ ๋ฒ์ ์๋ณต์ด ํ์ํ ์ ์์ต๋๋ค.
+
+GraphQL
+
+- ํด๋ผ์ด์ธํธ๊ฐ ํ์ํ ๋ฐ์ดํฐ๋ฅผ ์ ํํ๊ฒ ์ฟผ๋ฆฌํ ์ ์๋ ๋จ์ผ ์๋ํฌ์ธํธ๋ฅผ ์ ๊ณตํฉ๋๋ค.
+- ํด๋ผ์ด์ธํธ๊ฐ ์ค์ฒฉ ์ฟผ๋ฆฌ์ ํ์ํ ์ ํํ ํ๋๋ฅผ ์ง์ ํ๋ฉด ์๋ฒ๋ ํด๋น ํ๋๋ง ํฌํจํ ์ต์ ํ๋ ํ์ด๋ก๋๋ฅผ ๋ฐํํฉ๋๋ค.
+- ๋ฐ์ดํฐ ์์ ์ ์ํ ๋ฎคํ
์ด์
๊ณผ ์ค์๊ฐ ์๋ฆผ์ ์ํ ๊ตฌ๋
์ ์ง์ํฉ๋๋ค.
+- ์ฌ๋ฌ ์์ค์ ๋ฐ์ดํฐ๋ฅผ ์์งํ๋๋ฐ ์ ํฉํ๋ฉฐ ๋น ๋ฅด๊ฒ ์งํํ๋ ํ๋ฐํธ์๋ ์๊ตฌ์ฌํญ์ ์ ๋ง์ต๋๋ค.
+- ํ์ง๋ง ๋ณต์ก์ฑ์ ํด๋ผ์ด์ธํธ ์ธก์ผ๋ก ์ ๊ฐํ๋ฉฐ, ์ ๋๋ก ๋ณดํธํ์ง ์์ผ๋ฉด ์
์์ ์ธ ์ฟผ๋ฆฌ๋ฅผ ํ์ฉํ ์ ์์ต๋๋ค.
+- ์บ์ฑ ์ ๋ต์ REST๋ณด๋ค ๋ ๋ณต์กํ ์ ์์ต๋๋ค.
+
+์ ํ๋ฆฌ์ผ์ด์
๊ณผ ๊ฐ๋ฐํ์ ๊ตฌ์ฒด์ ์ธ ์๊ตฌ์ฌํญ์ ๋ฐ๋ผ REST์ GraphQL ์ค ์ ํฉํ ๊ฒ์ ์ ํํด์ผ ํฉ๋๋ค. GraphQL์ ๋ณต์กํ๊ฑฐ๋ ์์ฃผ ๋ณ๊ฒฝ๋๋ ํ๋ฐํธ์๋ ์๊ตฌ์ฌํญ์ ์ ํฉํ๋ฉฐ, REST๋ ๋จ์ํ๊ณ ์ผ๊ด๋ ๊ณ์ฝ์ด ์ ํธ๋๋ ์ ํ๋ฆฌ์ผ์ด์
์ ์ ํฉํฉ๋๋ค.
+
+๋ API ๋ฐฉ์ ๋ชจ๋ ์์ด์์ ์๋๋๋ค. ์ฌ๋ฐ๋ฅธ ์คํ์ผ์ ์ ํํ๋ ค๋ฉด ์๊ตฌ ์ฌํญ๊ณผ ์ฅ๋จ์ ์ ์ ์คํ๊ฒ ํ๊ฐํ๋ ๊ฒ์ด ์ค์ํฉ๋๋ค. REST์ GraphQL์ ๋ชจ๋ ๋ฐ์ดํฐ๋ฅผ ๋
ธ์ถํ๊ณ ์ต์ ์ ํ๋ฆฌ์ผ์ด์
์ ๊ตฌ๋ํ๋ ๋ฐ ์ ํจํ ์ต์
์
๋๋ค.
+
+
+### How does gRPC work?
+
+RPC(Remote Procedure Call)๋ ๋ง์ดํฌ๋ก์๋น์ค ์ํคํ
์ฒ์์ ์๋น์ค๊ฐ ์๋ก ๋ค๋ฅธ ์๋ฒ์ ๋ฐฐํฌ๋ ๋ ์๊ฒฉ ์๋น์ค ๊ฐ์ ํต์ ์ ๊ฐ๋ฅํ๊ฒ ํ๊ธฐ ๋๋ฌธ์ "**remote**"๋ผ๊ณ ๋ถ๋ฆฝ๋๋ค. ์ฌ์ฉ์ ์
์ฅ์์๋ ๋ก์ปฌ ํจ์ ํธ์ถ์ฒ๋ผ ์๋ํฉ๋๋ค.
+
+์๋ ๋ค์ด์ด๊ทธ๋จ์ **gRPC**์ ์ ์ฒด ๋ฐ์ดํฐ ํ๋ก์ฐ๋ฅผ ๋ณด์ฌ์ค๋๋ค.
+
+
+
+
+
+1๋จ๊ณ: ํด๋ผ์ด์ธํธ์์ REST ํธ์ถ์ ์ํํฉ๋๋ค. request body๋ ์ผ๋ฐ์ ์ผ๋ก JSON ํฌ๋งท์
๋๋ค.
+
+2-4๋จ๊ณ: ์ฃผ๋ฌธ ์๋น์ค(gRPC ํด๋ผ์ด์ธํธ)๊ฐ REST ํธ์ถ์ ์์ ํ์ฌ ๋ณํํ ํ ๊ฒฐ์ ์๋น์ค์ RPC ํธ์ถ์ ํฉ๋๋ค. gRPC๋ **client stub**์ ๋ฐ์ด๋๋ฆฌ๋ก ์ธ์ฝ๋ฉํ์ฌ ๋ก์ฐ๋ ๋ฒจ ํธ๋์คํฌํธ ๋ ์ด์ด๋ก ๋ณด๋
๋๋ค.
+
+5๋จ๊ณ: gRPC๊ฐ HTTP2๋ฅผ ํตํด ํจํท์ ์ ์กํฉ๋๋ค. ๋ฐ์ด๋๋ฆฌ ์ธ์ฝ๋ฉ๊ณผ ๋คํธ์ํฌ ์ต์ ํ๋ก ์ธํด gRPC๋ JSON๋ณด๋ค 5๋ฐฐ ๋น ๋ฅด๋ค๊ณ ํฉ๋๋ค.
+
+6-8๋จ๊ณ: ๊ฒฐ์ ์๋น์ค(gRPC ์๋ฒ)๊ฐ ๋คํธ์ํฌ์์ ํจํท์ ์์ ํ๊ณ , ์ด๋ฅผ ๋์ฝ๋ฉํ ํ ์๋ฒ ์ ํ๋ฆฌ์ผ์ด์
์ ํธ์ถํฉ๋๋ค.
+
+9-11๋จ๊ณ: ์๋ฒ ์ ํ๋ฆฌ์ผ์ด์
์์ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํ๊ณ ์ธ์ฝ๋ฉํ์ฌ ํธ๋์คํฌํธ ๋ ์ด์ด๋ก ์ ์กํฉ๋๋ค.
+
+12-14๋จ๊ณ: ์ฃผ๋ฌธ ์๋น์ค๊ฐ ํจํท์ ์์ ํ์ฌ ๋์ฝ๋ฉํ ํ ๊ฒฐ๊ณผ๋ฅผ ํด๋ผ์ด์ธํธ ์ ํ๋ฆฌ์ผ์ด์
์ ๋ณด๋
๋๋ค.
+
+### What is a webhook?
+
+์๋ ๋ค์ด์ด๊ทธ๋จ์ ํด๋ง๊ณผ ์นํ
์ ๋น๊ตํ ๊ฒ์
๋๋ค.
+
+
+
+
+
+์ ์์๊ฑฐ๋ ์น์ฌ์ดํธ๋ฅผ ์ด์ํ๋ค๊ณ ๊ฐ์ ํด ๋ณด๊ฒ ์ต๋๋ค. ํด๋ผ์ด์ธํธ๊ฐ API ๊ฒ์ดํธ์จ์ด๋ฅผ ํตํด ์ฃผ๋ฌธ ์๋น์ค๋ก ์ฃผ๋ฌธ์ ๋ณด๋ด๋ฉด, ์ฃผ๋ฌธ ์๋น์ค๋ ๊ฒฐ์ ํธ๋์ญ์
์ ์ํด ๊ฒฐ์ ์๋น์ค๋ก ์ด๋ํฉ๋๋ค. ๊ทธ๋ฌ๋ฉด ๊ฒฐ์ ์๋น์ค๋ ์ธ๋ถ ๊ฒฐ์ ์๋น์ค ๊ณต๊ธ์
์ฒด(PSP)์ ํต์ ํ์ฌ ํธ๋์ญ์
์ ์๋ฃํฉ๋๋ค.
+
+์ธ๋ถ PSP์์ ํต์ ์ ์ฒ๋ฆฌํ๋ ๋ฐฉ๋ฒ์๋ ๋ ๊ฐ์ง๊ฐ ์์ต๋๋ค.
+
+**1. ์ ํด๋ง Short polling**ย
+
+๊ฒฐ์ ์์ฒญ์ PSP์ ์ ์กํ ํ ๊ฒฐ์ ์๋น์ค์์ PSP์ ๊ฒฐ์ ์ํ๋ฅผ ๊ณ์ ๋ฌป์ต๋๋ค. ๋ช ๋ฒ์ ๋ผ์ด๋๊ฐ ๋๋๋ฉด PSP๋ ๋ง์นจ๋ด ์ํ๋ฅผ ๋ฐํํฉ๋๋ค.ย
+
+์ ํด๋ง์๋ ๋ ๊ฐ์ง ๋จ์ ์ด ์์ต๋๋ค.
+* ์ํ๋ฅผ ์ง์์ ์ผ๋ก ํด๋งํ๋ ค๋ฉด ๊ฒฐ์ ์๋น์ค์ ๋ฆฌ์์ค๊ฐ ํ์ํฉ๋๋ค.
+* ์ธ๋ถ ์๋น์ค๊ฐ ๊ฒฐ์ ์๋น์ค์ ์ง์ ํต์ ํ๋ฏ๋ก ๋ณด์ ์ทจ์ฝ์ ์ด ๋ฐ์ํ ์ ์์ต๋๋ค.
+
+**2. ์นํ
Webhook**ย
+
+์ธ๋ถ ์๋น์ค์ ์นํ
์ ๋ฑ๋กํ ์ ์์ต๋๋ค. ์ฆ, ์์ฒญ์ ๋ํ ์
๋ฐ์ดํธ๊ฐ ์์ ๋ ํน์ URL๋ก ๋ค์ ํธ์ถํ๋ผ๋ ์๋ฏธ์
๋๋ค. PSP๊ฐ ์ฒ๋ฆฌ๋ฅผ ์๋ฃํ๋ฉด HTTP ์์ฒญ์ ํธ์ถํ์ฌ ๊ฒฐ์ ์ํ๋ฅผ ์
๋ฐ์ดํธํฉ๋๋ค.
+
+์ด๋ฌํ ๋ฐฉ์์ผ๋ก ํ๋ก๊ทธ๋๋ฐ ํจ๋ฌ๋ค์์ด ๋ฐ๋๊ณ ๊ฒฐ์ ์๋น์ค๋ ๋ ์ด์ ๊ฒฐ์ ์ํ๋ฅผ ํด๋งํ๊ธฐ ์ํด ๋ฆฌ์์ค๋ฅผ ๋ญ๋นํ ํ์๊ฐ ์์ต๋๋ค.
+
+PSP๊ฐ ๋ค์ ์๋ตํ์ง ์์ผ๋ฉด ์ด๋ป๊ฒ ํ๋์? ๋งค์๊ฐ ๊ฒฐ์ ์ํ๋ฅผ ํ์ธํ๋๋ก ํ์ฐ์คํคํ ์์
์ ์ค์ ํ ์ ์์ต๋๋ค.
+
+์นํ
์ ์๋ฒ๊ฐ ํด๋ผ์ด์ธํธ์ HTTP ์์ฒญ์ ๋ณด๋ด๊ธฐ ๋๋ฌธ์ ๋ฆฌ๋ฒ์ค API ๋๋ ํธ์ API๋ผ๊ณ ๋ ๋ถ๋ฆฝ๋๋ค. ์นํ
์ ์ฌ์ฉํ ๋๋ ๋ค์ ์ธ ๊ฐ์ง ์ฌํญ์ ์ฃผ์ํด์ผ ํฉ๋๋ค.
+
+1. ์ธ๋ถ ์๋น์ค๊ฐ ํธ์ถํ ์ ์๋ ์ ์ ํ API๋ฅผ ์ค๊ณํด์ผ ํฉ๋๋ค.
+2. ๋ณด์์ ์ํด API ๊ฒ์ดํธ์จ์ด์ ์ ์ ํ ๊ท์น์ ์ค์ ํด์ผ ํฉ๋๋ค.
+3. ์ธ๋ถ ์๋น์ค์ ์ฌ๋ฐ๋ฅธ URL์ ๋ฑ๋กํด์ผ ํฉ๋๋ค.
+
+### How to improve API performance?
+
+The diagram below shows 5 common tricks to improve API performance.
+
+
+
+
+
+Pagination
+
+This is a common optimization when the size of the result is large. The results are streaming back to the client to improve the service responsiveness.
+
+Asynchronous Logging
+
+Synchronous logging deals with the disk for every call and can slow down the system. Asynchronous logging sends logs to a lock-free buffer first and immediately returns. The logs will be flushed to the disk periodically. This significantly reduces the I/O overhead.
+
+Caching
+
+We can store frequently accessed data into a cache. The client can query the cache first instead of visiting the database directly. If there is a cache miss, the client can query from the database. Caches like Redis store data in memory, so the data access is much faster than the database.
+
+Payload Compression
+
+The requests and responses can be compressed using gzip etc so that the transmitted data size is much smaller. This speeds up the upload and download.
+
+Connection Pool
+
+When accessing resources, we often need to load data from the database. Opening the closing db connections adds significant overhead. So we should connect to the db via a pool of open connections. The connection pool is responsible for managing the connection lifecycle.
+
+### HTTP 1.0 -> HTTP 1.1 -> HTTP 2.0 -> HTTP 3.0 (QUIC)
+
+What problem does each generation of HTTP solve?
+
+The diagram below illustrates the key features.
+
+
+
+
+
+- HTTP 1.0 was finalized and fully documented in 1996. Every request to the same server requires a separate TCP connection.
+
+- HTTP 1.1 was published in 1997. A TCP connection can be left open for reuse (persistent connection), but it doesnโt solve the HOL (head-of-line) blocking issue.
+
+ HOL blocking - when the number of allowed parallel requests in the browser is used up, subsequent requests need to wait for the former ones to complete.
+
+- HTTP 2.0 was published in 2015. It addresses HOL issue through request multiplexing, which eliminates HOL blocking at the application layer, but HOL still exists at the transport (TCP) layer.
+
+ As you can see in the diagram, HTTP 2.0 introduced the concept of HTTP โstreamsโ: an abstraction that allows multiplexing different HTTP exchanges onto the same TCP connection. Each stream doesnโt need to be sent in order.
+
+- HTTP 3.0 first draft was published in 2020. It is the proposed successor to HTTP 2.0. It uses QUIC instead of TCP for the underlying transport protocol, thus removing HOL blocking in the transport layer.
+
+QUIC is based on UDP. It introduces streams as first-class citizens at the transport layer. QUIC streams share the same QUIC connection, so no additional handshakes and slow starts are required to create new ones, but QUIC streams are delivered independently such that in most cases packet loss affecting one stream doesn't affect others.
+
+### SOAP vs REST vs GraphQL vs RPC
+
+The diagram below illustrates the API timeline and API styles comparison.
+
+Over time, different API architectural styles are released. Each of them has its own patterns of standardizing data exchange.
+
+You can check out the use cases of each style in the diagram.
+
+
+
+
+
+
+### Code First vs. API First
+
+The diagram below shows the differences between code-first development and API-first development. Why do we want to consider API first design?
+
+
+
+
+
+
+- Microservices increase system complexity and we have separate services to serve different functions of the system. While this kind of architecture facilitates decoupling and segregation of duty, we need to handle the various communications among services.
+
+It is better to think through the system's complexity before writing the code and carefully defining the boundaries of the services.
+
+- Separate functional teams need to speak the same language and the dedicated functional teams are only responsible for their own components and services. It is recommended that the organization speak the same language via API design.
+
+We can mock requests and responses to validate the API design before writing code.
+
+- Improve software quality and developer productivity Since we have ironed out most of the uncertainties when the project starts, the overall development process is smoother, and the software quality is greatly improved.
+
+Developers are happy about the process as well because they can focus on functional development instead of negotiating sudden changes.
+
+The possibility of having surprises toward the end of the project lifecycle is reduced.
+
+Because we have designed the API first, the tests can be designed while the code is being developed. In a way, we also have TDD (Test Driven Design) when using API first development.
+
+### HTTP status codes
+
+
+
+
+
+
+The response codes for HTTP are divided into five categories:
+
+Informational (100-199)
+Success (200-299)
+Redirection (300-399)
+Client Error (400-499)
+Server Error (500-599)
+
+### What does API gateway do?
+
+The diagram below shows the details.
+
+
+
+
+
+Step 1 - The client sends an HTTP request to the API gateway.
+
+Step 2 - The API gateway parses and validates the attributes in the HTTP request.
+
+Step 3 - The API gateway performs allow-list/deny-list checks.
+
+Step 4 - The API gateway talks to an identity provider for authentication and authorization.
+
+Step 5 - The rate limiting rules are applied to the request. If it is over the limit, the request is rejected.
+
+Steps 6 and 7 - Now that the request has passed basic checks, the API gateway finds the relevant service to route to by path matching.
+
+Step 8 - The API gateway transforms the request into the appropriate protocol and sends it to backend microservices.
+
+Steps 9-12: The API gateway can handle errors properly, and deals with faults if the error takes a longer time to recover (circuit break). It can also leverage ELK (Elastic-Logstash-Kibana) stack for logging and monitoring. We sometimes cache data in the API gateway.
+
+### How do we design effective and safe APIs?
+
+The diagram below shows typical API designs with a shopping cart example.
+
+
+
+
+
+
+Note that API design is not just URL path design. Most of the time, we need to choose the proper resource names, identifiers, and path patterns. It is equally important to design proper HTTP header fields or to design effective rate-limiting rules within the API gateway.
+
+### TCP/IP encapsulation
+
+How is data sent over the network? Why do we need so many layers in the OSI model?
+
+The diagram below shows how data is encapsulated and de-encapsulated when transmitting over the network.
+
+
+
+
+
+Step 1: When Device A sends data to Device B over the network via the HTTP protocol, it is first added an HTTP header at the application layer.
+
+Step 2: Then a TCP or a UDP header is added to the data. It is encapsulated into TCP segments at the transport layer. The header contains the source port, destination port, and sequence number.
+
+Step 3: The segments are then encapsulated with an IP header at the network layer. The IP header contains the source/destination IP addresses.
+
+Step 4: The IP datagram is added a MAC header at the data link layer, with source/destination MAC addresses.
+
+Step 5: The encapsulated frames are sent to the physical layer and sent over the network in binary bits.
+
+Steps 6-10: When Device B receives the bits from the network, it performs the de-encapsulation process, which is a reverse processing of the encapsulation process. The headers are removed layer by layer, and eventually, Device B can read the data.
+
+We need layers in the network model because each layer focuses on its own responsibilities. Each layer can rely on the headers for processing instructions and does not need to know the meaning of the data from the last layer.
+
+### Why is Nginx called a โreverseโ proxy?
+
+The diagram below shows the differences between a ๐๐จ๐ซ๐ฐ๐๐ซ๐ ๐ฉ๐ซ๐จ๐ฑ๐ฒ and a ๐ซ๐๐ฏ๐๐ซ๐ฌ๐ ๐ฉ๐ซ๐จ๐ฑ๐ฒ.
+
+
+
+
+
+A forward proxy is a server that sits between user devices and the internet.
+
+A forward proxy is commonly used for:
+
+1. Protecting clients
+2. Circumventing browsing restrictions
+3. Blocking access to certain content
+
+A reverse proxy is a server that accepts a request from the client, forwards the request to web servers, and returns the results to the client as if the proxy server had processed the request.
+
+A reverse proxy is good for:
+
+1. Protecting servers
+2. Load balancing
+3. Caching static contents
+4. Encrypting and decrypting SSL communications
+
+### What are the common load-balancing algorithms?
+
+The diagram below shows 6 common algorithms.
+
+
+
+
+
+- Static Algorithms
+
+1. Round robin
+
+ The client requests are sent to different service instances in sequential order. The services are usually required to be stateless.
+
+3. Sticky round-robin
+
+ This is an improvement of the round-robin algorithm. If Aliceโs first request goes to service A, the following requests go to service A as well.
+
+4. Weighted round-robin
+
+ The admin can specify the weight for each service. The ones with a higher weight handle more requests than others.
+
+6. Hash
+
+ This algorithm applies a hash function on the incoming requestsโ IP or URL. The requests are routed to relevant instances based on the hash function result.
+
+- Dynamic Algorithms
+
+5. Least connections
+
+ A new request is sent to the service instance with the least concurrent connections.
+
+7. Least response time
+
+ A new request is sent to the service instance with the fastest response time.
+
+### URL, URI, URN - Do you know the differences?
+
+The diagram below shows a comparison of URL, URI, and URN.
+
+
+
+
+
+- URI
+
+URI stands for Uniform Resource Identifier. It identifies a logical or physical resource on the web. URL and URN are subtypes of URI. URL locates a resource, while URN names a resource.
+
+A URI is composed of the following parts:
+scheme:[//authority]path[?query][#fragment]
+
+- URL
+
+URL stands for Uniform Resource Locator, the key concept of HTTP. It is the address of a unique resource on the web. It can be used with other protocols like FTP and JDBC.
+
+- URN
+
+URN stands for Uniform Resource Name. It uses the urn scheme. URNs cannot be used to locate a resource. A simple example given in the diagram is composed of a namespace and a namespace-specific string.
+
+If you would like to learn more detail on the subject, I would recommend [W3Cโs clarification](https://www.w3.org/TR/uri-clarification/).
+
+## CI/CD
+
+### CI/CD Pipeline Explained in Simple Terms
+
+
+
+
+
+Section 1 - SDLC with CI/CD
+
+The software development life cycle (SDLC) consists of several key stages: development, testing, deployment, and maintenance. CI/CD automates and integrates these stages to enable faster and more reliable releases.
+
+When code is pushed to a git repository, it triggers an automated build and test process. End-to-end (e2e) test cases are run to validate the code. If tests pass, the code can be automatically deployed to staging/production. If issues are found, the code is sent back to development for bug fixing. This automation provides fast feedback to developers and reduces the risk of bugs in production.
+
+Section 2 - Difference between CI and CD
+
+Continuous Integration (CI) automates the build, test, and merge process. It runs tests whenever code is committed to detect integration issues early. This encourages frequent code commits and rapid feedback.
+
+Continuous Delivery (CD) automates release processes like infrastructure changes and deployment. It ensures software can be released reliably at any time through automated workflows. CD may also automate the manual testing and approval steps required before production deployment.
+
+Section 3 - CI/CD Pipeline
+
+A typical CI/CD pipeline has several connected stages:
+- The developer commits code changes to the source control
+- CI server detects changes and triggers the build
+- Code is compiled, and tested (unit, integration tests)
+- Test results reported to the developer
+- On success, artifacts are deployed to staging environments
+- Further testing may be done on staging before release
+- CD system deploys approved changes to production
+
+### Netflix Tech Stack (CI/CD Pipeline)
+
+
+
+
+
+Planning: Netflix Engineering uses JIRA for planning and Confluence for documentation.
+
+Coding: Java is the primary programming language for the backend service, while other languages are used for different use cases.
+
+Build: Gradle is mainly used for building, and Gradle plugins are built to support various use cases.
+
+Packaging: Package and dependencies are packed into an Amazon Machine Image (AMI) for release.
+
+Testing: Testing emphasizes the production culture's focus on building chaos tools.
+
+Deployment: Netflix uses its self-built Spinnaker for canary rollout deployment.
+
+Monitoring: The monitoring metrics are centralized in Atlas, and Kayenta is used to detect anomalies.
+
+Incident report: Incidents are dispatched according to priority, and PagerDuty is used for incident handling.
+
+## Architecture patterns
+
+### MVC, MVP, MVVM, MVVM-C, and VIPER
+These architecture patterns are among the most commonly used in app development, whether on iOS or Android platforms. Developers have introduced them to overcome the limitations of earlier patterns. So, how do they differ?
+
+
+
+
+
+- MVC, the oldest pattern, dates back almost 50 years
+- Every pattern has a "view" (V) responsible for displaying content and receiving user input
+- Most patterns include a "model" (M) to manage business data
+- "Controller," "presenter," and "view-model" are translators that mediate between the view and the model ("entity" in the VIPER pattern)
+
+### 18 Key Design Patterns Every Developer Should Know
+
+Patterns are reusable solutions to common design problems, resulting in a smoother, more efficient development process. They serve as blueprints for building better software structures. These are some of the most popular patterns:
+
+
+
+
+
+- Abstract Factory: Family Creator - Makes groups of related items.
+- Builder: Lego Master - Builds objects step by step, keeping creation and appearance separate.
+- Prototype: Clone Maker - Creates copies of fully prepared examples.
+- Singleton: One and Only - A special class with just one instance.
+- Adapter: Universal Plug - Connects things with different interfaces.
+- Bridge: Function Connector - Links how an object works to what it does.
+- Composite: Tree Builder - Forms tree-like structures of simple and complex parts.
+- Decorator: Customizer - Adds features to objects without changing their core.
+- Facade: One-Stop-Shop - Represents a whole system with a single, simplified interface.
+- Flyweight: Space Saver - Shares small, reusable items efficiently.
+- Proxy: Stand-In Actor - Represents another object, controlling access or actions.
+- Chain of Responsibility: Request Relay - Passes a request through a chain of objects until handled.
+- Command: Task Wrapper - Turns a request into an object, ready for action.
+- Iterator: Collection Explorer - Accesses elements in a collection one by one.
+- Mediator: Communication Hub - Simplifies interactions between different classes.
+- Memento: Time Capsule - Captures and restores an object's state.
+- Observer: News Broadcaster - Notifies classes about changes in other objects.
+- Visitor: Skillful Guest - Adds new operations to a class without altering it.
+
+## Database
+
+### A nice cheat sheet of different databases in cloud services
+
+
+
+
+
+Choosing the right database for your project is a complex task. Many database options, each suited to distinct use cases, can quickly lead to decision fatigue.
+
+We hope this cheat sheet provides high-level direction to pinpoint the right service that aligns with your project's needs and avoid potential pitfalls.
+
+Note: Google has limited documentation for their database use cases. Even though we did our best to look at what was available and arrived at the best option, some of the entries may need to be more accurate.
+
+### 8 Data Structures That Power Your Databases
+
+The answer will vary depending on your use case. Data can be indexed in memory or on disk. Similarly, data formats vary, such as numbers, strings, geographic coordinates, etc. The system might be write-heavy or read-heavy. All of these factors affect your choice of database index format.
+
+
+
+
+
+The following are some of the most popular data structures used for indexing data:
+
+- Skiplist: a common in-memory index type. Used in Redis
+- Hash index: a very common implementation of the โMapโ data structure (or โCollectionโ)
+- SSTable: immutable on-disk โMapโ implementation
+- LSM tree: Skiplist + SSTable. High write throughput
+- B-tree: disk-based solution. Consistent read/write performance
+- Inverted index: used for document indexing. Used in Lucene
+- Suffix tree: for string pattern search
+- R-tree: multi-dimension search, such as finding the nearest neighbor
+
+### How is an SQL statement executed in the database?
+
+The diagram below shows the process. Note that the architectures for different databases are different, the diagram demonstrates some common designs.
+
+
+
+
+
+
+Step 1 - A SQL statement is sent to the database via a transport layer protocol (e.g.TCP).
+
+Step 2 - The SQL statement is sent to the command parser, where it goes through syntactic and semantic analysis, and a query tree is generated afterward.
+
+Step 3 - The query tree is sent to the optimizer. The optimizer creates an execution plan.
+
+Step 4 - The execution plan is sent to the executor. The executor retrieves data from the execution.
+
+Step 5 - Access methods provide the data fetching logic required for execution, retrieving data from the storage engine.
+
+Step 6 - Access methods decide whether the SQL statement is read-only. If the query is read-only (SELECT statement), it is passed to the buffer manager for further processing. The buffer manager looks for the data in the cache or data files.
+
+Step 7 - If the statement is an UPDATE or INSERT, it is passed to the transaction manager for further processing.
+
+Step 8 - During a transaction, the data is in lock mode. This is guaranteed by the lock manager. It also ensures the transactionโs ACID properties.
+
+### CAP theorem
+
+The CAP theorem is one of the most famous terms in computer science, but I bet different developers have different understandings. Letโs examine what it is and why it can be confusing.
+
+
+
+
+
+CAP theorem states that a distributed system can't provide more than two of these three guarantees simultaneously.
+
+**Consistency**: consistency means all clients see the same data at the same time no matter which node they connect to.
+
+**Availability**: availability means any client that requests data gets a response even if some of the nodes are down.
+
+**Partition Tolerance**: a partition indicates a communication break between two nodes. Partition tolerance means the system continues to operate despite network partitions.
+
+The โ2 of 3โ formulation can be useful, **but this simplification could be misleading**.
+
+1. Picking a database is not easy. Justifying our choice purely based on the CAP theorem is not enough. For example, companies don't choose Cassandra for chat applications simply because it is an AP system. There is a list of good characteristics that make Cassandra a desirable option for storing chat messages. We need to dig deeper.
+
+2. โCAP prohibits only a tiny part of the design space: perfect availability and consistency in the presence of partitions, which are rareโ. Quoted from the paper: CAP Twelve Years Later: How the โRulesโ Have Changed.
+
+3. The theorem is about 100% availability and consistency. A more realistic discussion would be the trade-offs between latency and consistency when there is no network partition. See PACELC theorem for more details.
+
+**Is the CAP theorem actually useful?**
+
+I think it is still useful as it opens our minds to a set of tradeoff discussions, but it is only part of the story. We need to dig deeper when picking the right database.
+
+### Types of Memory and Storage
+
+
+
+
+
+
+### Visualizing a SQL query
+
+
+
+
+
+SQL statements are executed by the database system in several steps, including:
+
+- Parsing the SQL statement and checking its validity
+- Transforming the SQL into an internal representation, such as relational algebra
+- Optimizing the internal representation and creating an execution plan that utilizes index information
+- Executing the plan and returning the results
+
+The execution of SQL is highly complex and involves many considerations, such as:
+
+- The use of indexes and caches
+- The order of table joins
+- Concurrency control
+- Transaction management
+
+### SQL language
+
+In 1986, SQL (Structured Query Language) became a standard. Over the next 40 years, it became the dominant language for relational database management systems. Reading the latest standard (ANSI SQL 2016) can be time-consuming. How can I learn it?
+
+
+
+
+
+There are 5 components of the SQL language:
+
+- DDL: data definition language, such as CREATE, ALTER, DROP
+- DQL: data query language, such as SELECT
+- DML: data manipulation language, such as INSERT, UPDATE, DELETE
+- DCL: data control language, such as GRANT, REVOKE
+- TCL: transaction control language, such as COMMIT, ROLLBACK
+
+For a backend engineer, you may need to know most of it. As a data analyst, you may need to have a good understanding of DQL. Select the topics that are most relevant to you.
+
+## Cache
+
+### Data is cached everywhere
+
+This diagram illustrates where we cache data in a typical architecture.
+
+
+
+
+
+
+There are **multiple layers** along the flow.
+
+1. Client apps: HTTP responses can be cached by the browser. We request data over HTTP for the first time, and it is returned with an expiry policy in the HTTP header; we request data again, and the client app tries to retrieve the data from the browser cache first.
+2. CDN: CDN caches static web resources. The clients can retrieve data from a CDN node nearby.
+3. Load Balancer: The load Balancer can cache resources as well.
+4. Messaging infra: Message brokers store messages on disk first, and then consumers retrieve them at their own pace. Depending on the retention policy, the data is cached in Kafka clusters for a period of time.
+5. Services: There are multiple layers of cache in a service. If the data is not cached in the CPU cache, the service will try to retrieve the data from memory. Sometimes the service has a second-level cache to store data on disk.
+6. Distributed Cache: Distributed cache like Redis holds key-value pairs for multiple services in memory. It provides much better read/write performance than the database.
+7. Full-text Search: we sometimes need to use full-text searches like Elastic Search for document search or log search. A copy of data is indexed in the search engine as well.
+8. Database: Even in the database, we have different levels of caches:
+- WAL(Write-ahead Log): data is written to WAL first before building the B tree index
+- Bufferpool: A memory area allocated to cache query results
+- Materialized View: Pre-compute query results and store them in the database tables for better query performance
+- Transaction log: record all the transactions and database updates
+- Replication Log: used to record the replication state in a database cluster
+
+### Why is Redis so fast?
+
+There are 3 main reasons as shown in the diagram below.
+
+
+
+
+
+
+1. Redis is a RAM-based data store. RAM access is at least 1000 times faster than random disk access.
+2. Redis leverages IO multiplexing and single-threaded execution loop for execution efficiency.
+3. Redis leverages several efficient lower-level data structures.
+
+Question: Another popular in-memory store is Memcached. Do you know the differences between Redis and Memcached?
+
+You might have noticed the style of this diagram is different from my previous posts. Please let me know which one you prefer.
+
+### How can Redis be used?
+
+
+
+
+
+
+There is more to Redis than just caching.
+
+Redis can be used in a variety of scenarios as shown in the diagram.
+
+- Session
+
+ We can use Redis to share user session data among different services.
+
+- Cache
+
+ We can use Redis to cache objects or pages, especially for hotspot data.
+
+- Distributed lock
+
+ We can use a Redis string to acquire locks among distributed services.
+
+- Counter
+
+ We can count how many likes or how many reads for articles.
+
+- Rate limiter
+
+ We can apply a rate limiter for certain user IPs.
+
+- Global ID generator
+
+ We can use Redis Int for global ID.
+
+- Shopping cart
+
+ We can use Redis Hash to represent key-value pairs in a shopping cart.
+
+- Calculate user retention
+
+ We can use Bitmap to represent the user login daily and calculate user retention.
+
+- Message queue
+
+ We can use List for a message queue.
+
+- Ranking
+
+ We can use ZSet to sort the articles.
+
+### Top caching strategies
+
+Designing large-scale systems usually requires careful consideration of caching.
+Below are five caching strategies that are frequently utilized.
+
+
+
+
+
+
+
+## Microservice architecture
+
+### What does a typical microservice architecture look like?
+
+
+
+
+
+
+The diagram below shows a typical microservice architecture.
+
+- Load Balancer: This distributes incoming traffic across multiple backend services.
+- CDN (Content Delivery Network): CDN is a group of geographically distributed servers that hold static content for faster delivery. The clients look for content in CDN first, then progress to backend services.
+- API Gateway: This handles incoming requests and routes them to the relevant services. It talks to the identity provider and service discovery.
+- Identity Provider: This handles authentication and authorization for users.
+- Service Registry & Discovery: Microservice registration and discovery happen in this component, and the API gateway looks for relevant services in this component to talk to.
+- Management: This component is responsible for monitoring the services.
+- Microservices: Microservices are designed and deployed in different domains. Each domain has its own database. The API gateway talks to the microservices via REST API or other protocols, and the microservices within the same domain talk to each other using RPC (Remote Procedure Call).
+
+Benefits of microservices:
+
+- They can be quickly designed, deployed, and horizontally scaled.
+- Each domain can be independently maintained by a dedicated team.
+- Business requirements can be customized in each domain and better supported, as a result.
+
+### Microservice Best Practices
+
+A picture is worth a thousand words: 9 best practices for developing microservices.
+
+
+
+
+
+
+When we develop microservices, we need to follow the following best practices:
+
+1. Use separate data storage for each microservice
+2. Keep code at a similar level of maturity
+3. Separate build for each microservice
+4. Assign each microservice with a single responsibility
+5. Deploy into containers
+6. Design stateless services
+7. Adopt domain-driven design
+8. Design micro frontend
+9. Orchestrating microservices
+
+### What tech stack is commonly used for microservices?
+
+Below you will find a diagram showing the microservice tech stack, both for the development phase and for production.
+
+
+
+
+
+
+โถ๏ธ ๐๐ซ๐-๐๐ซ๐จ๐๐ฎ๐๐ญ๐ข๐จ๐ง
+
+- Define API - This establishes a contract between frontend and backend. We can use Postman or OpenAPI for this.
+- Development - Node.js or react is popular for frontend development, and java/python/go for backend development. Also, we need to change the configurations in the API gateway according to API definitions.
+- Continuous Integration - JUnit and Jenkins for automated testing. The code is packaged into a Docker image and deployed as microservices.
+
+โถ๏ธ ๐๐ซ๐จ๐๐ฎ๐๐ญ๐ข๐จ๐ง
+
+- NGinx is a common choice for load balancers. Cloudflare provides CDN (Content Delivery Network).
+- API Gateway - We can use spring boot for the gateway, and use Eureka/Zookeeper for service discovery.
+- The microservices are deployed on clouds. We have options among AWS, Microsoft Azure, or Google GCP.
+Cache and Full-text Search - Redis is a common choice for caching key-value pairs. Elasticsearch is used for full-text search.
+- Communications - For services to talk to each other, we can use messaging infra Kafka or RPC.
+- Persistence - We can use MySQL or PostgreSQL for a relational database, and Amazon S3 for object store. We can also use Cassandra for the wide-column store if necessary.
+- Management & Monitoring - To manage so many microservices, the common Ops tools include Prometheus, Elastic Stack, and Kubernetes.
+
+### Why is Kafka fast
+
+There are many design decisions that contributed to Kafkaโs performance. In this post, weโll focus on two. We think these two carried the most weight.
+
+
+
+
+
+1. The first one is Kafkaโs reliance on Sequential I/O.
+2. The second design choice that gives Kafka its performance advantage is its focus on efficiency: zero copy principle.
+
+The diagram illustrates how the data is transmitted between producer and consumer, and what zero-copy means.
+
+- Step 1.1 - 1.3: Producer writes data to the disk
+- Step 2: Consumer reads data without zero-copy
+
+2.1 The data is loaded from disk to OS cache
+
+2.2 The data is copied from OS cache to Kafka application
+
+2.3 Kafka application copies the data into the socket buffer
+
+2.4 The data is copied from socket buffer to network card
+
+2.5 The network card sends data out to the consumer
+
+
+- Step 3: Consumer reads data with zero-copy
+
+3.1: The data is loaded from disk to OS cache
+3.2 OS cache directly copies the data to the network card via sendfile() command
+3.3 The network card sends data out to the consumer
+
+Zero copy is a shortcut to save the multiple data copies between application context and kernel context.
+
+## Payment systems
+
+### How to learn payment systems?
+
+
+
+
+
+### Why is the credit card called โthe most profitable product in banksโ? How does VISA/Mastercard make money?
+
+The diagram below shows the economics of the credit card payment flow.
+
+
+
+
+
+1. The cardholder pays a merchant $100 to buy a product.
+
+2. The merchant benefits from the use of the credit card with higher sales volume and needs to compensate the issuer and the card network for providing the payment service. The acquiring bank sets a fee with the merchant, called the โmerchant discount fee.โ
+
+3 - 4. The acquiring bank keeps $0.25 as the acquiring markup, and $1.75 is paid to the issuing bank as the interchange fee. The merchant discount fee should cover the interchange fee.
+
+ The interchange fee is set by the card network because it is less efficient for each issuing bank to negotiate fees with each merchant.
+
+5. The card network sets up the network assessments and fees with each bank, which pays the card network for its services every month. For example, VISA charges a 0.11% assessment, plus a $0.0195 usage fee, for every swipe.
+
+6. The cardholder pays the issuing bank for its services.
+
+Why should the issuing bank be compensated?
+
+- The issuer pays the merchant even if the cardholder fails to pay the issuer.
+- The issuer pays the merchant before the cardholder pays the issuer.
+- The issuer has other operating costs, including managing customer accounts, providing statements, fraud detection, risk management, clearing & settlement, etc.
+
+### How does VISA work when we swipe a credit card at a merchantโs shop?
+
+
+
+
+
+
+VISA, Mastercard, and American Express act as card networks for the clearing and settling of funds. The card acquiring bank and the card issuing bank can be โ and often are โ different. If banks were to settle transactions one by one without an intermediary, each bank would have to settle the transactions with all the other banks. This is quite inefficient.
+
+The diagram below shows VISAโs role in the credit card payment process. There are two flows involved. Authorization flow happens when the customer swipes the credit card. Capture and settlement flow happens when the merchant wants to get the money at the end of the day.
+
+- Authorization Flow
+
+Step 0: The card issuing bank issues credit cards to its customers.
+
+Step 1: The cardholder wants to buy a product and swipes the credit card at the Point of Sale (POS) terminal in the merchantโs shop.
+
+Step 2: The POS terminal sends the transaction to the acquiring bank, which has provided the POS terminal.
+
+Steps 3 and 4: The acquiring bank sends the transaction to the card network, also called the card scheme. The card network sends the transaction to the issuing bank for approval.
+
+Steps 4.1, 4.2 and 4.3: The issuing bank freezes the money if the transaction is approved. The approval or rejection is sent back to the acquirer, as well as the POS terminal.
+
+- Capture and Settlement Flow
+
+Steps 1 and 2: The merchant wants to collect the money at the end of the day, so they hit โcaptureโ on the POS terminal. The transactions are sent to the acquirer in batch. The acquirer sends the batch file with transactions to the card network.
+
+Step 3: The card network performs clearing for the transactions collected from different acquirers, and sends the clearing files to different issuing banks.
+
+Step 4: The issuing banks confirm the correctness of the clearing files, and transfer money to the relevant acquiring banks.
+
+Step 5: The acquiring bank then transfers money to the merchantโs bank.
+
+Step 4: The card network clears up the transactions from different acquiring banks. Clearing is a process in which mutual offset transactions are netted, so the number of total transactions is reduced.
+
+In the process, the card network takes on the burden of talking to each bank and receives service fees in return.
+
+### Payment Systems Around The World Series (Part 1): Unified Payments Interface (UPI) in India
+
+
+Whatโs UPI? UPI is an instant real-time payment system developed by the National Payments Corporation of India.
+
+It accounts for 60% of digital retail transactions in India today.
+
+UPI = payment markup language + standard for interoperable payments
+
+
+
+
+
+
+
+## DevOps
+
+### DevOps vs. SRE vs. Platform Engineering. What is the difference?
+
+The concepts of DevOps, SRE, and Platform Engineering have emerged at different times and have been developed by various individuals and organizations.
+
+
+
+
+
+DevOps as a concept was introduced in 2009 by Patrick Debois and Andrew Shafer at the Agile conference. They sought to bridge the gap between software development and operations by promoting a collaborative culture and shared responsibility for the entire software development lifecycle.
+
+SRE, or Site Reliability Engineering, was pioneered by Google in the early 2000s to address operational challenges in managing large-scale, complex systems. Google developed SRE practices and tools, such as the Borg cluster management system and the Monarch monitoring system, to improve the reliability and efficiency of their services.
+
+Platform Engineering is a more recent concept, building on the foundation of SRE engineering. The precise origins of Platform Engineering are less clear, but it is generally understood to be an extension of the DevOps and SRE practices, with a focus on delivering a comprehensive platform for product development that supports the entire business perspective.
+
+It's worth noting that while these concepts emerged at different times. They are all related to the broader trend of improving collaboration, automation, and efficiency in software development and operations.
+
+### What is k8s (Kubernetes)?
+
+K8s is a container orchestration system. It is used for container deployment and management. Its design is greatly impacted by Googleโs internal system Borg.
+
+
+
+
+
+A k8s cluster consists of a set of worker machines, called nodes, that run containerized applications. Every cluster has at least one worker node.
+
+The worker node(s) host the Pods that are the components of the application workload. The control plane manages the worker nodes and the Pods in the cluster. In production environments, the control plane usually runs across multiple computers, and a cluster usually runs multiple nodes, providing fault tolerance and high availability.
+
+- Control Plane Components
+
+1. API Server
+
+ The API server talks to all the components in the k8s cluster. All the operations on pods are executed by talking to the API server.
+
+2. Scheduler
+
+ The scheduler watches pod workloads and assigns loads on newly created pods.
+
+3. Controller Manager
+
+ The controller manager runs the controllers, including Node Controller, Job Controller, EndpointSlice Controller, and ServiceAccount Controller.
+
+4. Etcd
+
+ etcd is a key-value store used as Kubernetes' backing store for all cluster data.
+
+- Nodes
+
+1. Pods
+
+ A pod is a group of containers and is the smallest unit that k8s administers. Pods have a single IP address applied to every container within the pod.
+
+2. Kubelet
+
+ An agent that runs on each node in the cluster. It ensures containers are running in a Pod.
+
+3. Kube Proxy
+
+ Kube-proxy is a network proxy that runs on each node in your cluster. It routes traffic coming into a node from the service. It forwards requests for work to the correct containers.
+
+### Docker vs. Kubernetes. Which one should we use?
+
+
+
+
+
+
+What is Docker ?
+
+Docker is an open-source platform that allows you to package, distribute, and run applications in isolated containers. It focuses on containerization, providing lightweight environments that encapsulate applications and their dependencies.
+
+What is Kubernetes ?
+
+Kubernetes, often referred to as K8s, is an open-source container orchestration platform. It provides a framework for automating the deployment, scaling, and management of containerized applications across a cluster of nodes.
+
+How are both different from each other ?
+
+Docker: Docker operates at the individual container level on a single operating system host.
+
+You must manually manage each host and setting up networks, security policies, and storage for multiple related containers can be complex.
+
+Kubernetes: Kubernetes operates at the cluster level. It manages multiple containerized applications across multiple hosts, providing automation for tasks like load balancing, scaling, and ensuring the desired state of applications.
+
+In short, Docker focuses on containerization and running containers on individual hosts, while Kubernetes specializes in managing and orchestrating containers at scale across a cluster of hosts.
+
+### How does Docker work?
+
+The diagram below shows the architecture of Docker and how it works when we run โdocker buildโ, โdocker pullโ
+and โdocker runโ.
+
+
+
+
+
+There are 3 components in Docker architecture:
+
+- Docker client
+
+ The docker client talks to the Docker daemon.
+
+- Docker host
+
+ The Docker daemon listens for Docker API requests and manages Docker objects such as images, containers, networks, and volumes.
+
+- Docker registry
+
+ A Docker registry stores Docker images. Docker Hub is a public registry that anyone can use.
+
+Letโs take the โdocker runโ command as an example.
+
+ 1. Docker pulls the image from the registry.
+ 1. Docker creates a new container.
+ 1. Docker allocates a read-write filesystem to the container.
+ 1. Docker creates a network interface to connect the container to the default network.
+ 1. Docker starts the container.
+
+## GIT
+
+### How Git Commands work
+
+To begin with, it's essential to identify where our code is stored. The common assumption is that there are only two locations - one on a remote server like Github and the other on our local machine. However, this isn't entirely accurate. Git maintains three local storages on our machine, which means that our code can be found in four places:
+
+
+
+
+
+
+- Working directory: where we edit files
+- Staging area: a temporary location where files are kept for the next commit
+- Local repository: contains the code that has been committed
+- Remote repository: the remote server that stores the code
+
+Most Git commands primarily move files between these four locations.
+
+### How does Git Work?
+
+The diagram below shows the Git workflow.
+
+
+
+
+
+
+Git is a distributed version control system.
+
+Every developer maintains a local copy of the main repository and edits and commits to the local copy.
+
+The commit is very fast because the operation doesnโt interact with the remote repository.
+
+If the remote repository crashes, the files can be recovered from the local repositories.
+
+### Git merge vs. Git rebase
+
+What are the differences?
+
+
+
+
+
+
+When we **merge changes** from one Git branch to another, we can use โgit mergeโ or โgit rebaseโ. The diagram below shows how the two commands work.
+
+**Git merge**
+
+This creates a new commit Gโ in the main branch. Gโ ties the histories of both main and feature branches.
+
+Git merge is **non-destructive**. Neither the main nor the feature branch is changed.
+
+**Git rebase**
+
+Git rebase moves the feature branch histories to the head of the main branch. It creates new commits Eโ, Fโ, and Gโ for each commit in the feature branch.
+
+The benefit of rebase is that it has a linear **commit history**.
+
+Rebase can be dangerous if โthe golden rule of git rebaseโ is not followed.
+
+**The Golden Rule of Git Rebase**
+
+Never use it on public branches!
+
+## Cloud Services
+
+### A nice cheat sheet of different cloud services (2023 edition)
+
+
+
+
+
+
+### What is cloud native?
+
+Below is a diagram showing the evolution of architecture and processes since the 1980s.
+
+
+
+
+
+Organizations can build and run scalable applications on public, private, and hybrid clouds using cloud native technologies.
+
+This means the applications are designed to leverage cloud features, so they are resilient to load and easy to scale.
+
+Cloud native includes 4 aspects:
+
+1. Development process
+
+ This has progressed from waterfall to agile to DevOps.
+
+2. Application Architecture
+
+ The architecture has gone from monolithic to microservices. Each service is designed to be small, adaptive to the limited resources in cloud containers.
+
+3. Deployment & packaging
+
+ The applications used to be deployed on physical servers. Then around 2000, the applications that were not sensitive to latency were usually deployed on virtual servers. With cloud native applications, they are packaged into docker images and deployed in containers.
+
+4. Application infrastructure
+
+ The applications are massively deployed on cloud infrastructure instead of self-hosted servers.
+
+## Developer productivity tools
+
+### Visualize JSON files
+
+Nested JSON files are hard to read.
+
+**JsonCrack** generates graph diagrams from JSON files and makes them easy to read.
+
+Additionally, the generated diagrams can be downloaded as images.
+
+
+
+
+
+
+### Automatically turn code into architecture diagrams
+
+
+
+
+
+
+What does it do?
+
+- Draw the cloud system architecture in Python code.
+- Diagrams can also be rendered directly inside the Jupyter Notebooks.
+- No design tools are needed.
+- Supports the following providers: AWS, Azure, GCP, Kubernetes, Alibaba Cloud, Oracle Cloud, etc.
+
+[Github repo](https://github.com/mingrammer/diagrams)
+
+## Linux
+
+### Linux file system explained
+
+
+
+
+
+The Linux file system used to resemble an unorganized town where individuals constructed their houses wherever they pleased. However, in 1994, the Filesystem Hierarchy Standard (FHS) was introduced to bring order to the Linux file system.
+
+By implementing a standard like the FHS, software can ensure a consistent layout across various Linux distributions. Nonetheless, not all Linux distributions strictly adhere to this standard. They often incorporate their own unique elements or cater to specific requirements.
+To become proficient in this standard, you can begin by exploring. Utilize commands such as "cd" for navigation and "ls" for listing directory contents. Imagine the file system as a tree, starting from the root (/). With time, it will become second nature to you, transforming you into a skilled Linux administrator.
+
+### 18 Most-used Linux Commands You Should Know
+
+Linux commands are instructions for interacting with the operating system. They help manage files, directories, system processes, and many other aspects of the system. You need to become familiar with these commands in order to navigate and maintain Linux-based systems efficiently and effectively.
+
+This diagram below shows popular Linux commands:
+
+
+
+
+
+
+- ls - List files and directories
+- cd - Change the current directory
+- mkdir - Create a new directory
+- rm - Remove files or directories
+- cp - Copy files or directories
+- mv - Move or rename files or directories
+- chmod - Change file or directory permissions
+- grep - Search for a pattern in files
+- find - Search for files and directories
+- tar - manipulate tarball archive files
+- vi - Edit files using text editors
+- cat - display the content of files
+- top - Display processes and resource usage
+- ps - Display processes information
+- kill - Terminate a process by sending a signal
+- du - Estimate file space usage
+- ifconfig - Configure network interfaces
+- ping - Test network connectivity between hosts
+
+## Security
+
+### How does HTTPS work?
+
+Hypertext Transfer Protocol Secure (HTTPS) is an extension of the Hypertext Transfer Protocol (HTTP.) HTTPS transmits encrypted data using Transport Layer Security (TLS.) If the data is hijacked online, all the hijacker gets is binary code.
+
+
+
+
+
+
+How is the data encrypted and decrypted?
+
+Step 1 - The client (browser) and the server establish a TCP connection.
+
+Step 2 - The client sends a โclient helloโ to the server. The message contains a set of necessary encryption algorithms (cipher suites) and the latest TLS version it can support. The server responds with a โserver helloโ so the browser knows whether it can support the algorithms and TLS version.
+
+The server then sends the SSL certificate to the client. The certificate contains the public key, host name, expiry dates, etc. The client validates the certificate.
+
+Step 3 - After validating the SSL certificate, the client generates a session key and encrypts it using the public key. The server receives the encrypted session key and decrypts it with the private key.
+
+Step 4 - Now that both the client and the server hold the same session key (symmetric encryption), the encrypted data is transmitted in a secure bi-directional channel.
+
+Why does HTTPS switch to symmetric encryption during data transmission? There are two main reasons:
+
+1. Security: The asymmetric encryption goes only one way. This means that if the server tries to send the encrypted data back to the client, anyone can decrypt the data using the public key.
+
+2. Server resources: The asymmetric encryption adds quite a lot of mathematical overhead. It is not suitable for data transmissions in long sessions.
+
+### Oauth 2.0 Explained With Simple Terms.
+
+OAuth 2.0 is a powerful and secure framework that allows different applications to securely interact with each other on behalf of users without sharing sensitive credentials.
+
+
+
+
+
+The entities involved in OAuth are the User, the Server, and the Identity Provider (IDP).
+
+What Can an OAuth Token Do?
+
+When you use OAuth, you get an OAuth token that represents your identity and permissions. This token can do a few important things:
+
+Single Sign-On (SSO): With an OAuth token, you can log into multiple services or apps using just one login, making life easier and safer.
+
+Authorization Across Systems: The OAuth token allows you to share your authorization or access rights across various systems, so you don't have to log in separately everywhere.
+
+Accessing User Profile: Apps with an OAuth token can access certain parts of your user profile that you allow, but they won't see everything.
+
+Remember, OAuth 2.0 is all about keeping you and your data safe while making your online experiences seamless and hassle-free across different applications and services.
+
+### Top 4 Forms of Authentication Mechanisms
+
+
+
+
+
+1. SSH Keys:
+
+ Cryptographic keys are used to access remote systems and servers securely
+
+1. OAuth Tokens:
+
+ Tokens that provide limited access to user data on third-party applications
+
+1. SSL Certificates:
+
+ Digital certificates ensure secure and encrypted communication between servers and clients
+
+1. Credentials:
+
+ User authentication information is used to verify and grant access to various systems and services
+
+### Session, cookie, JWT, token, SSO, and OAuth 2.0 - what are they?
+
+These terms are all related to user identity management. When you log into a website, you declare who you are (identification). Your identity is verified (authentication), and you are granted the necessary permissions (authorization). Many solutions have been proposed in the past, and the list keeps growing.
+
+
+
+
+
+From simple to complex, here is my understanding of user identity management:
+
+- WWW-Authenticate is the most basic method. You are asked for the username and password by the browser. As a result of the inability to control the login life cycle, it is seldom used today.
+
+- A finer control over the login life cycle is session-cookie. The server maintains session storage, and the browser keeps the ID of the session. A cookie usually only works with browsers and is not mobile app friendly.
+
+- To address the compatibility issue, the token can be used. The client sends the token to the server, and the server validates the token. The downside is that the token needs to be encrypted and decrypted, which may be time-consuming.
+
+- JWT is a standard way of representing tokens. This information can be verified and trusted because it is digitally signed. Since JWT contains the signature, there is no need to save session information on the server side.
+
+- By using SSO (single sign-on), you can sign on only once and log in to multiple websites. It uses CAS (central authentication service) to maintain cross-site information.
+
+- By using OAuth 2.0, you can authorize one website to access your information on another website.
+
+### How to store passwords safely in the database and how to validate a password?
+
+
+
+
+
+
+**Things NOT to do**
+
+- Storing passwords in plain text is not a good idea because anyone with internal access can see them.
+
+- Storing password hashes directly is not sufficient because it is pruned to precomputation attacks, such as rainbow tables.
+
+- To mitigate precomputation attacks, we salt the passwords.
+
+**What is salt?**
+
+According to OWASP guidelines, โa salt is a unique, randomly generated string that is added to each password as part of the hashing processโ.
+
+**How to store a password and salt?**
+
+1. the hash result is unique to each password.
+1. The password can be stored in the database using the following format: hash(password + salt).
+
+**How to validate a password?**
+
+To validate a password, it can go through the following process:
+
+1. A client enters the password.
+1. The system fetches the corresponding salt from the database.
+1. The system appends the salt to the password and hashes it. Letโs call the hashed value H1.
+1. The system compares H1 and H2, where H2 is the hash stored in the database. If they are the same, the password is valid.
+
+### Explaining JSON Web Token (JWT) to a 10 year old Kid
+
+
+
+
+
+Imagine you have a special box called a JWT. Inside this box, there are three parts: a header, a payload, and a signature.
+
+The header is like the label on the outside of the box. It tells us what type of box it is and how it's secured. It's usually written in a format called JSON, which is just a way to organize information using curly braces { } and colons : .
+
+The payload is like the actual message or information you want to send. It could be your name, age, or any other data you want to share. It's also written in JSON format, so it's easy to understand and work with.
+Now, the signature is what makes the JWT secure. It's like a special seal that only the sender knows how to create. The signature is created using a secret code, kind of like a password. This signature ensures that nobody can tamper with the contents of the JWT without the sender knowing about it.
+
+When you want to send the JWT to a server, you put the header, payload, and signature inside the box. Then you send it over to the server. The server can easily read the header and payload to understand who you are and what you want to do.
+
+### How does Google Authenticator (or other types of 2-factor authenticators) work?
+
+Google Authenticator is commonly used for logging into our accounts when 2-factor authentication is enabled. How does it guarantee security?
+
+Google Authenticator is a software-based authenticator that implements a two-step verification service. The diagram below provides detail.
+
+
+
+
+
+
+There are two stages involved:
+
+- Stage 1 - The user enables Google two-step verification.
+- Stage 2 - The user uses the authenticator for logging in, etc.
+
+Letโs look at these stages.
+
+**Stage 1**
+
+Steps 1 and 2: Bob opens the web page to enable two-step verification. The front end requests a secret key. The authentication service generates the secret key for Bob and stores it in the database.
+
+Step 3: The authentication service returns a URI to the front end. The URI is composed of a key issuer, username, and secret key. The URI is displayed in the form of a QR code on the web page.
+
+Step 4: Bob then uses Google Authenticator to scan the generated QR code. The secret key is stored in the authenticator.
+
+**Stage 2**
+Steps 1 and 2: Bob wants to log into a website with Google two-step verification. For this, he needs the password. Every 30 seconds, Google Authenticator generates a 6-digit password using TOTP (Time-based One Time Password) algorithm. Bob uses the password to enter the website.
+
+Steps 3 and 4: The frontend sends the password Bob enters to the backend for authentication. The authentication service reads the secret key from the database and generates a 6-digit password using the same TOTP algorithm as the client.
+
+Step 5: The authentication service compares the two passwords generated by the client and the server, and returns the comparison result to the frontend. Bob can proceed with the login process only if the two passwords match.
+
+Is this authentication mechanism safe?
+
+- Can the secret key be obtained by others?
+
+ We need to make sure the secret key is transmitted using HTTPS. The authenticator client and the database store the secret key, and we need to make sure the secret keys are encrypted.
+
+- Can the 6-digit password be guessed by hackers?
+
+ No. The password has 6 digits, so the generated password has 1 million potential combinations. Plus, the password changes every 30 seconds. If hackers want to guess the password in 30 seconds, they need to enter 30,000 combinations per second.
+
+
+## Real World Case Studies
+
+### Netflix's Tech Stack
+
+This post is based on research from many Netflix engineering blogs and open-source projects. If you come across any inaccuracies, please feel free to inform us.
+
+
+
+
+
+**Mobile and web**: Netflix has adopted Swift and Kotlin to build native mobile apps. For its web application, it uses React.
+
+**Frontend/server communication**: Netflix uses GraphQL.
+
+**Backend services**: Netflix relies on ZUUL, Eureka, the Spring Boot framework, and other technologies.
+
+**Databases**: Netflix utilizes EV cache, Cassandra, CockroachDB, and other databases.
+
+**Messaging/streaming**: Netflix employs Apache Kafka and Fink for messaging and streaming purposes.
+
+**Video storage**: Netflix uses S3 and Open Connect for video storage.
+
+**Data processing**: Netflix utilizes Flink and Spark for data processing, which is then visualized using Tableau. Redshift is used for processing structured data warehouse information.
+
+**CI/CD**: Netflix employs various tools such as JIRA, Confluence, PagerDuty, Jenkins, Gradle, Chaos Monkey, Spinnaker, Atlas, and more for CI/CD processes.
+
+### Twitter Architecture 2022
+
+Yes, this is the real Twitter architecture. It is posted by Elon Musk and redrawn by us for better readability.
+
+
+
+
+
+
+### Evolution of Airbnbโs microservice architecture over the past 15 years
+
+Airbnbโs microservice architecture went through 3 main stages.
+
+
+
+
+
+
+Monolith (2008 - 2017)
+
+Airbnb began as a simple marketplace for hosts and guests. This is built in a Ruby on Rails application - the monolith.
+
+Whatโs the challenge?
+
+- Confusing team ownership + unowned code
+- Slow deployment
+
+Microservices (2017 - 2020)
+
+Microservice aims to solve those challenges. In the microservice architecture, key services include:
+
+- Data fetching service
+- Business logic data service
+- Write workflow service
+- UI aggregation service
+- Each service had one owning team
+
+Whatโs the challenge?
+
+Hundreds of services and dependencies were difficult for humans to manage.
+
+Micro + macroservices (2020 - present)
+
+This is what Airbnb is working on now. The micro and macroservice hybrid model focuses on the unification of APIs.
+
+### Monorepo vs. Microrepo.
+
+Which is the best? Why do different companies choose different options?
+
+
+
+
+
+
+Monorepo isn't new; Linux and Windows were both created using Monorepo. To improve scalability and build speed, Google developed its internal dedicated toolchain to scale it faster and strict coding quality standards to keep it consistent.
+
+Amazon and Netflix are major ambassadors of the Microservice philosophy. This approach naturally separates the service code into separate repositories. It scales faster but can lead to governance pain points later on.
+
+Within Monorepo, each service is a folder, and every folder has a BUILD config and OWNERS permission control. Every service member is responsible for their own folder.
+
+On the other hand, in Microrepo, each service is responsible for its repository, with the build config and permissions typically set for the entire repository.
+
+In Monorepo, dependencies are shared across the entire codebase regardless of your business, so when there's a version upgrade, every codebase upgrades their version.
+
+In Microrepo, dependencies are controlled within each repository. Businesses choose when to upgrade their versions based on their own schedules.
+
+Monorepo has a standard for check-ins. Google's code review process is famously known for setting a high bar, ensuring a coherent quality standard for Monorepo, regardless of the business.
+
+Microrepo can either set its own standard or adopt a shared standard by incorporating the best practices. It can scale faster for business, but the code quality might be a bit different.
+Google engineers built Bazel, and Meta built Buck. There are other open-source tools available, including Nx, Lerna, and others.
+
+Over the years, Microrepo has had more supported tools, including Maven and Gradle for Java, NPM for NodeJS, and CMake for C/C++, among others.
+
+### How will you design the Stack Overflow website?
+
+If your answer is on-premise servers and monolith (on the bottom of the following image), you would likely fail the interview, but that's how it is built in reality!
+
+
+
+
+
+
+**What people think it should look like**
+
+The interviewer is probably expecting something like the top portion of the picture.
+
+- Microservice is used to decompose the system into small components.
+- Each service has its own database. Use cache heavily.
+- The service is sharded.
+- The services talk to each other asynchronously through message queues.
+- The service is implemented using Event Sourcing with CQRS.
+- Showing off knowledge in distributed systems such as eventual consistency, CAP theorem, etc.
+
+**What it actually is**
+
+Stack Overflow serves all the traffic with only 9 on-premise web servers, and itโs on monolith! It has its own servers and does not run on the cloud.
+
+This is contrary to all our popular beliefs these days.
+
+### Why did Amazon Prime Video monitoring move from serverless to monolithic? How can it save 90% cost?
+
+The diagram below shows the architecture comparison before and after the migration.
+
+
+
+
+
+
+What is Amazon Prime Video Monitoring Service?
+
+Prime Video service needs to monitor the quality of thousands of live streams. The monitoring tool automatically analyzes the streams in real time and identifies quality issues like block corruption, video freeze, and sync problems. This is an important process for customer satisfaction.
+
+There are 3 steps: media converter, defect detector, and real-time notification.
+
+- What is the problem with the old architecture?
+
+ The old architecture was based on Amazon Lambda, which was good for building services quickly. However, it was not cost-effective when running the architecture at a high scale. The two most expensive operations are:
+
+1. The orchestration workflow - AWS step functions charge users by state transitions and the orchestration performs multiple state transitions every second.
+
+2. Data passing between distributed components - the intermediate data is stored in Amazon S3 so that the next stage can download. The download can be costly when the volume is high.
+
+- Monolithic architecture saves 90% cost
+
+ A monolithic architecture is designed to address the cost issues. There are still 3 components, but the media converter and defect detector are deployed in the same process, saving the cost of passing data over the network. Surprisingly, this approach to deployment architecture change led to 90% cost savings!
+
+This is an interesting and unique case study because microservices have become a go-to and fashionable choice in the tech industry. It's good to see that we are having more discussions about evolving the architecture and having more honest discussions about its pros and cons. Decomposing components into distributed microservices comes with a cost.
+
+- What did Amazon leaders say about this?
+
+ Amazon CTO Werner Vogels: โBuilding **evolvable software systems** is a strategy, not a religion. And revisiting your architecture with an open mind is a must.โ
+
+Ex Amazon VP Sustainability Adrian Cockcroft: โThe Prime Video team had followed a path I call **Serverless First**โฆI donโt advocate **Serverless Only**โ.
+
+### How does Disney Hotstar capture 5 Billion Emojis during a tournament?
+
+
+
+
+
+
+1. Clients send emojis through standard HTTP requests. You can think of Golang Service as a typical Web Server. Golang is chosen because it supports concurrency well. Threads in Golang are lightweight.
+
+2. Since the write volume is very high, Kafka (message queue) is used as a buffer.
+
+3. Emoji data are aggregated by a streaming processing service called Spark. It aggregates data every 2 seconds, which is configurable. There is a trade-off to be made based on the interval. A shorter interval means emojis are delivered to other clients faster but it also means more computing resources are needed.
+
+4. Aggregated data is written to another Kafka.
+
+5. The PubSub consumers pull aggregated emoji data from Kafka.
+
+6. Emojis are delivered to other clients in real-time through the PubSub infrastructure. The PubSub infrastructure is interesting. Hotstar considered the following protocols: Socketio, NATS, MQTT, and gRPC, and settled with MQTT.
+
+A similar design is adopted by LinkedIn which streams a million likes/sec.
+
+### How Discord Stores Trillions Of Messages
+
+The diagram below shows the evolution of message storage at Discord:
+
+
+
+
+
+
+MongoDB โก๏ธ Cassandra โก๏ธ ScyllaDB
+
+In 2015, the first version of Discord was built on top of a single MongoDB replica. Around Nov 2015, MongoDB stored 100 million messages and the RAM couldnโt hold the data and index any longer. The latency became unpredictable. Message storage needs to be moved to another database. Cassandra was chosen.
+
+In 2017, Discord had 12 Cassandra nodes and stored billions of messages.
+
+At the beginning of 2022, it had 177 nodes with trillions of messages. At this point, latency was unpredictable, and maintenance operations became too expensive to run.
+
+There are several reasons for the issue:
+
+- Cassandra uses the LSM tree for the internal data structure. The reads are more expensive than the writes. There can be many concurrent reads on a server with hundreds of users, resulting in hotspots.
+- Maintaining clusters, such as compacting SSTables, impacts performance.
+- Garbage collection pauses would cause significant latency spikes
+
+ScyllaDB is Cassandra compatible database written in C++. Discord redesigned its architecture to have a monolithic API, a data service written in Rust, and ScyllaDB-based storage.
+
+The p99 read latency in ScyllaDB is 15ms compared to 40-125ms in Cassandra. The p99 write latency is 5ms compared to 5-70ms in Cassandra.
+
+### How do video live streamings work on YouTube, TikTok live, or Twitch?
+
+Live streaming differs from regular streaming because the video content is sent via the internet in real-time, usually with a latency of just a few seconds.
+
+The diagram below explains what happens behind the scenes to make this possible.
+
+
+
+
+
+
+Step 1: The raw video data is captured by a microphone and camera. The data is sent to the server side.
+
+Step 2: The video data is compressed and encoded. For example, the compressing algorithm separates the background and other video elements. After compression, the video is encoded to standards such as H.264. The size of the video data is much smaller after this step.
+
+Step 3: The encoded data is divided into smaller segments, usually seconds in length, so it takes much less time to download or stream.
+
+Step 4: The segmented data is sent to the streaming server. The streaming server needs to support different devices and network conditions. This is called โAdaptive Bitrate Streaming.โ This means we need to produce multiple files at different bitrates in steps 2 and 3.
+
+Step 5: The live streaming data is pushed to edge servers supported by CDN (Content Delivery Network.) Millions of viewers can watch the video from an edge server nearby. CDN significantly lowers data transmission latency.
+
+Step 6: The viewersโ devices decode and decompress the video data and play the video in a video player.
+
+Steps 7 and 8: If the video needs to be stored for replay, the encoded data is sent to a storage server, and viewers can request a replay from it later.
+
+Standard protocols for live streaming include:
+
+- RTMP (Real-Time Messaging Protocol): This was originally developed by Macromedia to transmit data between a Flash player and a server. Now it is used for streaming video data over the internet. Note that video conferencing applications like Skype use RTC (Real-Time Communication) protocol for lower latency.
+- HLS (HTTP Live Streaming): It requires the H.264 or H.265 encoding. Apple devices accept only HLS format.
+- DASH (Dynamic Adaptive Streaming over HTTP): DASH does not support Apple devices.
+- Both HLS and DASH support adaptive bitrate streaming.
+
+## License
+
+This work is licensed under CC BY-NC-ND 4.0
From ee05b4aac8cca20387221f1aed92c43f2d09ae1b Mon Sep 17 00:00:00 2001
From: Deadintegral
Date: Fri, 26 Jan 2024 20:19:09 +0900
Subject: [PATCH 02/16] docs: translate how to improve api performance
---
translations/README-kr.md | 12 ++++++------
1 file changed, 6 insertions(+), 6 deletions(-)
diff --git a/translations/README-kr.md b/translations/README-kr.md
index 5df8f36..d541326 100644
--- a/translations/README-kr.md
+++ b/translations/README-kr.md
@@ -242,7 +242,7 @@ PSP๊ฐ ๋ค์ ์๋ตํ์ง ์์ผ๋ฉด ์ด๋ป๊ฒ ํ๋์? ๋งค์๊ฐ ๊ฒฐ์ ์
### How to improve API performance?
-The diagram below shows 5 common tricks to improve API performance.
+์๋ ๋ค์ด์ด๊ทธ๋จ์ API ์ฑ๋ฅ์ ๊ฐ์ ํ๋ 5๊ฐ์ง ์ผ๋ฐ์ ์ธ ๋ฐฉ๋ฒ์ ๋ณด์ฌ์ค๋๋ค.
@@ -250,23 +250,23 @@ The diagram below shows 5 common tricks to improve API performance.
Pagination
-This is a common optimization when the size of the result is large. The results are streaming back to the client to improve the service responsiveness.
+์ด๋ ๊ฒฐ๊ณผ์ ํฌ๊ธฐ๊ฐ ํด ๋ ์ผ๋ฐ์ ์ผ๋ก ์ฌ์ฉํ๋ ์ต์ ํ ๋ฐฉ๋ฒ์
๋๋ค. ์๋น์ค ์๋ต์ฑ์ ๊ฐ์ ํ๊ธฐ ์ํด ๊ฒฐ๊ณผ๋ฅผ ํด๋ผ์ด์ธํธ๋ก ๋ค์ ์คํธ๋ฆฌ๋ฐํฉ๋๋ค.
Asynchronous Logging
-Synchronous logging deals with the disk for every call and can slow down the system. Asynchronous logging sends logs to a lock-free buffer first and immediately returns. The logs will be flushed to the disk periodically. This significantly reduces the I/O overhead.
+๋๊ธฐ์ ๋ก๊น
์ ๋ชจ๋ ํธ์ถ์ ๋ํด ๋์คํฌ๋ฅผ ์ฒ๋ฆฌํ๋ฏ๋ก ์์คํ
์๋๊ฐ ๋๋ ค์ง ์ ์์ต๋๋ค. ๋น๋๊ธฐ ๋ก๊น
์ ๋ก๊ทธ๋ฅผ ์ ๊ธ ์๋ ๋ฒํผ๋ก ๋จผ์ ์ ์กํ ํ ์ฆ์ ๋ฐํํฉ๋๋ค. ๋ก๊ทธ๋ ์ฃผ๊ธฐ์ ์ผ๋ก ๋์คํฌ์ ํ๋ฌ์๋ฉ๋๋ค. ๋ฐ๋ผ์ I/O ์ค๋ฒํค๋๊ฐ ํฌ๊ฒ ์ค์ด๋ญ๋๋ค.
Caching
-We can store frequently accessed data into a cache. The client can query the cache first instead of visiting the database directly. If there is a cache miss, the client can query from the database. Caches like Redis store data in memory, so the data access is much faster than the database.
+์์ฃผ ์ก์ธ์คํ๋ ๋ฐ์ดํฐ๋ฅผ ์บ์์ ์ ์ฅํ ์ ์์ต๋๋ค. ํด๋ผ์ด์ธํธ๋ ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ฅผ ์ง์ ๋ฐฉ๋ฌธํ๋ ๋์ ์บ์๋ฅผ ๋จผ์ ์ฟผ๋ฆฌํ ์ ์์ต๋๋ค. ์บ์์ ๋ฏธ์ค๊ฐ ์๋ ๊ฒฝ์ฐ ํด๋ผ์ด์ธํธ๋ ๋ฐ์ดํฐ๋ฒ ์ด์ค์์ ์ฟผ๋ฆฌํ ์ ์์ต๋๋ค. Redis์ ๊ฐ์ ์บ์๋ ๋ฐ์ดํฐ๋ฅผ ๋ฉ๋ชจ๋ฆฌ์ ์ ์ฅํ๋ฏ๋ก ๋ฐ์ดํฐ ์ก์ธ์ค๊ฐ ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ณด๋ค ํจ์ฌ ๋น ๋ฆ
๋๋ค.
Payload Compression
-The requests and responses can be compressed using gzip etc so that the transmitted data size is much smaller. This speeds up the upload and download.
+์์ฒญ๊ณผ ์๋ต์ gzip ๋ฑ์ ์ฌ์ฉํ์ฌ ์์ถํ ์ ์์ผ๋ฏ๋ก ์ ์ก๋๋ ๋ฐ์ดํฐ ํฌ๊ธฐ๊ฐ ํจ์ฌ ์์์ง๋๋ค. ์ด๋ ๊ฒ ํ๋ฉด ์
๋ก๋์ ๋ค์ด๋ก๋ ์๋๊ฐ ๋นจ๋ผ์ง๋๋ค.
Connection Pool
-When accessing resources, we often need to load data from the database. Opening the closing db connections adds significant overhead. So we should connect to the db via a pool of open connections. The connection pool is responsible for managing the connection lifecycle.
+๋ฆฌ์์ค์ ์ก์ธ์คํ ๋ ๋ฐ์ดํฐ๋ฒ ์ด์ค์์ ๋ฐ์ดํฐ๋ฅผ ๋ก๋ํด์ผ ํ๋ ๊ฒฝ์ฐ๊ฐ ์ข
์ข
์์ต๋๋ค. ๋ซํ ์๋ ๋ฐ์ดํฐ๋ฒ ์ด์ค ์ปค๋ฅ์
์ ์ด๋ฉด ์๋นํ ์ค๋ฒํค๋๊ฐ ์ถ๊ฐ๋ฉ๋๋ค. ๋ฐ๋ผ์ ์คํ ์ปค๋ฅ์
ํ์ ํตํด ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ์ฐ๊ฒฐํด์ผ ํฉ๋๋ค. ์ปค๋ฅ์
ํ์ ์ปค๋ฅ์
๋ผ์ดํ์ฌ์ดํด์ ๊ด๋ฆฌํ๋ ์ญํ ์ ํฉ๋๋ค.
### HTTP 1.0 -> HTTP 1.1 -> HTTP 2.0 -> HTTP 3.0 (QUIC)
From 4f760eb96ea08687904f2f1affcadd272393c0a6 Mon Sep 17 00:00:00 2001
From: Deadintegral
Date: Sat, 27 Jan 2024 22:52:46 +0900
Subject: [PATCH 03/16] docs: translate to uniform resource
---
translations/README-kr.md | 157 +++++++++++++++++++-------------------
1 file changed, 78 insertions(+), 79 deletions(-)
diff --git a/translations/README-kr.md b/translations/README-kr.md
index d541326..4e018bb 100644
--- a/translations/README-kr.md
+++ b/translations/README-kr.md
@@ -18,7 +18,6 @@
์๊ฐ ์๋ฃ์ ๊ฐ๋จํ ์ฉ์ด๋ฅผ ์ฌ์ฉํ์ฌ ๋ณต์กํ ์์คํ
์ ์ค๋ช
ํฉ๋๋ค.
-Whether you're preparing for a System Design Interview or you simply want to understand how systems work beneath the surface, we hope this repository will help you achieve that.
์์คํ
๋์์ธ ๋ฉด์ ์ ์ค๋น ์ค์ด๊ฑฐ๋ ๋จ์ํ ์์คํ
์ด ํ๋ฉด ์๋์์ ์ด๋ป๊ฒ ์๋ํ๋์ง ์ดํดํ๊ณ ์ถ์ผ์ ๋ถ์ด๋ผ๋ฉด ์ด ๋ฆฌํฌ์งํ ๋ฆฌ๊ฐ ๋์์ด ๋๊ธธ ๋ฐ๋๋๋ค.
# Table of Contents
@@ -196,13 +195,13 @@ RPC(Remote Procedure Call)๋ ๋ง์ดํฌ๋ก์๋น์ค ์ํคํ
์ฒ์์ ์๋น์ค
1๋จ๊ณ: ํด๋ผ์ด์ธํธ์์ REST ํธ์ถ์ ์ํํฉ๋๋ค. request body๋ ์ผ๋ฐ์ ์ผ๋ก JSON ํฌ๋งท์
๋๋ค.
-2-4๋จ๊ณ: ์ฃผ๋ฌธ ์๋น์ค(gRPC ํด๋ผ์ด์ธํธ)๊ฐ REST ํธ์ถ์ ์์ ํ์ฌ ๋ณํํ ํ ๊ฒฐ์ ์๋น์ค์ RPC ํธ์ถ์ ํฉ๋๋ค. gRPC๋ **client stub**์ ๋ฐ์ด๋๋ฆฌ๋ก ์ธ์ฝ๋ฉํ์ฌ ๋ก์ฐ๋ ๋ฒจ ํธ๋์คํฌํธ ๋ ์ด์ด๋ก ๋ณด๋
๋๋ค.
+2-4๋จ๊ณ: ์ฃผ๋ฌธ ์๋น์ค(gRPC ํด๋ผ์ด์ธํธ)๊ฐ REST ํธ์ถ์ ์์ ํ์ฌ ๋ณํํ ํ ๊ฒฐ์ ์๋น์ค์ RPC ํธ์ถ์ ํฉ๋๋ค. gRPC๋ **client stub**์ ๋ฐ์ด๋๋ฆฌ๋ก ์ธ์ฝ๋ฉํ์ฌ ๋ก์ฐ๋ ๋ฒจ ์ ์ก ๊ณ์ธต์ผ๋ก ๋ณด๋
๋๋ค.
5๋จ๊ณ: gRPC๊ฐ HTTP2๋ฅผ ํตํด ํจํท์ ์ ์กํฉ๋๋ค. ๋ฐ์ด๋๋ฆฌ ์ธ์ฝ๋ฉ๊ณผ ๋คํธ์ํฌ ์ต์ ํ๋ก ์ธํด gRPC๋ JSON๋ณด๋ค 5๋ฐฐ ๋น ๋ฅด๋ค๊ณ ํฉ๋๋ค.
6-8๋จ๊ณ: ๊ฒฐ์ ์๋น์ค(gRPC ์๋ฒ)๊ฐ ๋คํธ์ํฌ์์ ํจํท์ ์์ ํ๊ณ , ์ด๋ฅผ ๋์ฝ๋ฉํ ํ ์๋ฒ ์ ํ๋ฆฌ์ผ์ด์
์ ํธ์ถํฉ๋๋ค.
-9-11๋จ๊ณ: ์๋ฒ ์ ํ๋ฆฌ์ผ์ด์
์์ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํ๊ณ ์ธ์ฝ๋ฉํ์ฌ ํธ๋์คํฌํธ ๋ ์ด์ด๋ก ์ ์กํฉ๋๋ค.
+9-11๋จ๊ณ: ์๋ฒ ์ ํ๋ฆฌ์ผ์ด์
์์ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํ๊ณ ์ธ์ฝ๋ฉํ์ฌ ์ ์ก ๊ณ์ธต์ผ๋ก ์ ์กํฉ๋๋ค.
12-14๋จ๊ณ: ์ฃผ๋ฌธ ์๋น์ค๊ฐ ํจํท์ ์์ ํ์ฌ ๋์ฝ๋ฉํ ํ ๊ฒฐ๊ณผ๋ฅผ ํด๋ผ์ด์ธํธ ์ ํ๋ฆฌ์ผ์ด์
์ ๋ณด๋
๋๋ค.
@@ -223,8 +222,8 @@ RPC(Remote Procedure Call)๋ ๋ง์ดํฌ๋ก์๋น์ค ์ํคํ
์ฒ์์ ์๋น์ค
๊ฒฐ์ ์์ฒญ์ PSP์ ์ ์กํ ํ ๊ฒฐ์ ์๋น์ค์์ PSP์ ๊ฒฐ์ ์ํ๋ฅผ ๊ณ์ ๋ฌป์ต๋๋ค. ๋ช ๋ฒ์ ๋ผ์ด๋๊ฐ ๋๋๋ฉด PSP๋ ๋ง์นจ๋ด ์ํ๋ฅผ ๋ฐํํฉ๋๋ค.ย
์ ํด๋ง์๋ ๋ ๊ฐ์ง ๋จ์ ์ด ์์ต๋๋ค.
-* ์ํ๋ฅผ ์ง์์ ์ผ๋ก ํด๋งํ๋ ค๋ฉด ๊ฒฐ์ ์๋น์ค์ ๋ฆฌ์์ค๊ฐ ํ์ํฉ๋๋ค.
-* ์ธ๋ถ ์๋น์ค๊ฐ ๊ฒฐ์ ์๋น์ค์ ์ง์ ํต์ ํ๋ฏ๋ก ๋ณด์ ์ทจ์ฝ์ ์ด ๋ฐ์ํ ์ ์์ต๋๋ค.
+- ์ํ๋ฅผ ์ง์์ ์ผ๋ก ํด๋งํ๋ ค๋ฉด ๊ฒฐ์ ์๋น์ค์ ๋ฆฌ์์ค๊ฐ ํ์ํฉ๋๋ค.
+- ์ธ๋ถ ์๋น์ค๊ฐ ๊ฒฐ์ ์๋น์ค์ ์ง์ ํต์ ํ๋ฏ๋ก ๋ณด์ ์ทจ์ฝ์ ์ด ๋ฐ์ํ ์ ์์ต๋๋ค.
**2. ์นํ
Webhook**ย
@@ -270,35 +269,35 @@ Connection Pool
### HTTP 1.0 -> HTTP 1.1 -> HTTP 2.0 -> HTTP 3.0 (QUIC)
-What problem does each generation of HTTP solve?
+๊ฐ ์ธ๋์ HTTP๋ ์ด๋ค ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋์?
-The diagram below illustrates the key features.
+์๋ ๋ค์ด์ด๊ทธ๋จ์ ์ฃผ์ ํน์ง์ ๋ณด์ฌ์ค๋๋ค.
-- HTTP 1.0 was finalized and fully documented in 1996. Every request to the same server requires a separate TCP connection.
+- HTTP 1.0์ 1996๋
์ ์์ฑ๋์ด ์์ ํ ๋ฌธ์ํ๋์์ต๋๋ค. ๋์ผํ ์๋ฒ์ ๋ํ ๋ชจ๋ ์์ฒญ์๋ ๋ณ๋์ TCP ์ฐ๊ฒฐ์ด ํ์ํฉ๋๋ค.
-- HTTP 1.1 was published in 1997. A TCP connection can be left open for reuse (persistent connection), but it doesnโt solve the HOL (head-of-line) blocking issue.
+- HTTP 1.1์ 1997๋
์ ๋ฐํ๋์์ต๋๋ค. TCP ์ปค๋ฅ์
์ ์ฌ์ฌ์ฉ(persistent connection)์ ์ํด ์ด์ด๋ ์ ์์ง๋ง, HOL(head-of-line) ์ฐจ๋จ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ์ง๋ ๋ชปํฉ๋๋ค.
- HOL blocking - when the number of allowed parallel requests in the browser is used up, subsequent requests need to wait for the former ones to complete.
+ HOL ์ฐจ๋จ - ๋ธ๋ผ์ฐ์ ์์ ํ์ฉํ๋ ๋ณ๋ ฌ ์์ฒญ์ ์๋ฅผ ๋ชจ๋ ์ฌ์ฉํ๋ฉด ํ์ ์์ฒญ์ ์ด์ ์์ฒญ์ด ์๋ฃ๋ ๋๊น์ง ๊ธฐ๋ค๋ ค์ผ ํฉ๋๋ค.
-- HTTP 2.0 was published in 2015. It addresses HOL issue through request multiplexing, which eliminates HOL blocking at the application layer, but HOL still exists at the transport (TCP) layer.
+- HTTP 2.0์ 2015๋
์ ๋ฐํ๋์์ต๋๋ค. ์ด๋ ์์ฒญ ๋ค์คํ๋ฅผ ํตํด HOL ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ์ฌ ์์ฉ ๊ณ์ธต์์ HOL ์ฐจ๋จ์ ์ ๊ฑฐํ์ง๋ง, ์ ์ก(TCP) ๊ณ์ธต์๋ ์ฌ์ ํ HOL์ด ์กด์ฌํฉ๋๋ค.
- As you can see in the diagram, HTTP 2.0 introduced the concept of HTTP โstreamsโ: an abstraction that allows multiplexing different HTTP exchanges onto the same TCP connection. Each stream doesnโt need to be sent in order.
+ ๋ค์ด์ด๊ทธ๋จ์์ ๋ณผ ์ ์๋ฏ์ด HTTP 2.0์ ๋์ผํ TCP ์ปค๋ฅ์
์ ์๋ก ๋ค๋ฅธ HTTP ๊ตํ์ ๋ค์คํํ ์ ์๋ ์ถ์ํ ๊ฐ๋
์ธ HTTP "steam"์ ๋์
ํ์ต๋๋ค. ๊ฐ ์คํธ๋ฆผ์ ์์๋๋ก ์ ์กํ ํ์๋ ์์ต๋๋ค.
-- HTTP 3.0 first draft was published in 2020. It is the proposed successor to HTTP 2.0. It uses QUIC instead of TCP for the underlying transport protocol, thus removing HOL blocking in the transport layer.
+- HTTP 3.0 ์ด์์ 2020๋
์ ๋ฐํ๋์์ต๋๋ค. HTTP 2.0์ ํ์ ๋ฒ์ ์ผ๋ก ์ ์๋์์ต๋๋ค. ๊ธฐ๋ณธ ํธ๋์คํฌํธ ํ๋กํ ์ฝ๋ก TCP ๋์ QUIC์ ์ฌ์ฉํ๋ฏ๋ก ์ ์ก ๊ณ์ธต์์ HOL ์ฐจ๋จ์ด ์ ๊ฑฐ๋ฉ๋๋ค.
-QUIC is based on UDP. It introduces streams as first-class citizens at the transport layer. QUIC streams share the same QUIC connection, so no additional handshakes and slow starts are required to create new ones, but QUIC streams are delivered independently such that in most cases packet loss affecting one stream doesn't affect others.
+QUIC์ UDP๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํฉ๋๋ค. ์ด๋ ์ ์ก ๊ณ์ธต์์ ์คํธ๋ฆผ์ ํผ์คํธ ํด๋์ค ์ํฐ์ฆ์ผ๋ก ์๊ฐํฉ๋๋ค. QUIC ์คํธ๋ฆผ์ ๋์ผํ QUIC ์ปค๋ฅ์
์ ๊ณต์ ํ๋ฏ๋ก ์ ์คํธ๋ฆผ์ ์์ฑํ๊ธฐ ์ํด ์ถ๊ฐ์ ์ธ ํธ๋์
ฐ์ดํฌ๋ ์ฌ๋ก์ฐ ์คํํธ๊ฐ ํ์ํ์ง ์์ผ๋ฉฐ, ๋๋ถ๋ถ์ ๊ฒฝ์ฐ ํ ์คํธ๋ฆผ์ ์ํฅ์ ๋ฏธ์น๋ ํจํท ์์ค์ด ๋ค๋ฅธ ์คํธ๋ฆผ์ ์ํฅ์ ๋ฏธ์น์ง ์๋๋ก ๋
๋ฆฝ์ ์ผ๋ก ์ ๋ฌ๋ฉ๋๋ค.
### SOAP vs REST vs GraphQL vs RPC
-The diagram below illustrates the API timeline and API styles comparison.
+์๋ ๋ค์ด์ด๊ทธ๋จ์ API ํ์๋ผ์ธ๊ณผ API ์คํ์ผ์ ๋น๊ตํ ๊ฒ์
๋๋ค.
-Over time, different API architectural styles are released. Each of them has its own patterns of standardizing data exchange.
+์๊ฐ์ด ์ง๋จ์ ๋ฐ๋ผ ๋ค์ํ API ์ํคํ
์ฒ ์คํ์ผ์ด ์ถ์๋ฉ๋๋ค. ๊ฐ ์คํ์ผ์๋ ๋ฐ์ดํฐ ๊ตํ์ ํ์คํํ๋ ๊ณ ์ ํ ํจํด์ด ์์ต๋๋ค.
-You can check out the use cases of each style in the diagram.
+๋ค์ด์ด๊ทธ๋จ์์ ๊ฐ ์คํ์ผ์ ์ฌ์ฉ ์ฌ๋ก๋ฅผ ํ์ธํ ์ ์์ต๋๋ค.
@@ -307,28 +306,28 @@ You can check out the use cases of each style in the diagram.
### Code First vs. API First
-The diagram below shows the differences between code-first development and API-first development. Why do we want to consider API first design?
+์๋ ๋ค์ด์ด๊ทธ๋จ์ ์ฝ๋ ํผ์คํธ ๊ฐ๋ฐ๊ณผ API ํผ์คํธ ๊ฐ๋ฐ์ ์ฐจ์ด์ ์ ๋ณด์ฌ์ค๋๋ค. API ํผ์คํธ ์ค๊ณ๋ฅผ ๊ณ ๋ คํด์ผ ํ๋ ์ด์ ๋ ๋ฌด์์ธ๊ฐ์?
-- Microservices increase system complexity and we have separate services to serve different functions of the system. While this kind of architecture facilitates decoupling and segregation of duty, we need to handle the various communications among services.
+- ๋ง์ดํฌ๋ก์๋น์ค๋ ์์คํ
๋ณต์ก์ฑ์ ์ฆ๊ฐ์ํค๋ฉฐ, ์์คํ
์ ๋ค์ํ ๊ธฐ๋ฅ์ ๋ด๋นํ๋ ๋ณ๋์ ์๋น์ค๋ฅผ ์ ๊ณตํฉ๋๋ค. ์ด๋ฌํ ์ํคํ
์ฒ๋ ์
๋ฌด์ ๋์ปคํ๋ง๊ณผ ๋ถ๋ฆฌ๋ฅผ ์ฉ์ดํ๊ฒ ํ์ง๋ง ์๋น์ค ๊ฐ์ ๋ค์ํ ์ปค๋ฎค๋์ผ์ด์
์ ์ฒ๋ฆฌํด์ผ ํฉ๋๋ค.
-It is better to think through the system's complexity before writing the code and carefully defining the boundaries of the services.
+์ฝ๋๋ฅผ ์์ฑํ๊ธฐ ์ ์ ์์คํ
์ ๋ณต์ก์ฑ์ ๊ณ ๋ คํ๊ณ ์๋น์ค์ ๋ฒ์๋ฅผ ์ ์คํ๊ฒ ์ ์ํ๋ ๊ฒ์ด ์ข์ต๋๋ค.
-- Separate functional teams need to speak the same language and the dedicated functional teams are only responsible for their own components and services. It is recommended that the organization speak the same language via API design.
+- ๊ธฐ๋ฅ์กฐ์ง์ ๋์ผํ ์ธ์ด๋ก ์์ฌ์ํตํด์ผ ํ๋ฉฐ, ๋ชฉ์ ์กฐ์ง์ ์์ฒด ์ปดํฌ๋ํธ์ ์๋น์ค์๋ง ์ฑ
์์ด ์์ต๋๋ค. API ์ค๊ณ๋ฅผ ํตํด ์กฐ์ง์ด ๋์ผํ ์ธ์ด๋ก ์์ฌ์ํตํ๋ ๊ฒ์ด ์ข์ต๋๋ค.
-We can mock requests and responses to validate the API design before writing code.
+์ฝ๋๋ฅผ ์์ฑํ๊ธฐ ์ ์ ์์ฒญ๊ณผ ์๋ต์ ๋ชจ์๋ก ์์ฑํ์ฌ API ์ค๊ณ๋ฅผ ๊ฒ์ฆํ ์ ์์ต๋๋ค.
-- Improve software quality and developer productivity Since we have ironed out most of the uncertainties when the project starts, the overall development process is smoother, and the software quality is greatly improved.
+- ์ํํธ์จ์ด ํ์ง๊ณผ ๊ฐ๋ฐ์ ์์ฐ์ฑ์ด ํฅ์๋ฉ๋๋ค. ํ๋ก์ ํธ๊ฐ ์์๋ ๋ ๋๋ถ๋ถ์ ๋ถํ์ค์ฑ์ ์ ๊ฑฐํ๊ธฐ ๋๋ฌธ์ ์ ๋ฐ์ ์ธ ๊ฐ๋ฐ ํ๋ก์ธ์ค๊ฐ ๋ ์ํํด์ง๊ณ ์ํํธ์จ์ด ํ์ง์ด ํฌ๊ฒ ํฅ์๋ฉ๋๋ค.
-Developers are happy about the process as well because they can focus on functional development instead of negotiating sudden changes.
+๊ฐ๋ฐ์๋ ๊ฐ์์ค๋ฌ์ด ๋ณ๊ฒฝ ์ฌํญ์ ๋
ผ์ํ๋ ๋์ ๊ธฐ๋ฅ ๊ฐ๋ฐ์ ์ง์คํ ์ ์๊ธฐ ๋๋ฌธ์ ์ด ํ๋ก์ธ์ค์ ๋ง์กฑํฉ๋๋ค.
-The possibility of having surprises toward the end of the project lifecycle is reduced.
+ํ๋ก์ ํธ ๋ผ์ดํ์ฌ์ดํด์ด ๋๋ ๋ฌด๋ ต์ ์ํ๋ผ์ด์ฆ๊ฐ ๋ฐ์ํ ๊ฐ๋ฅ์ฑ์ด ์ค์ด๋ญ๋๋ค.
-Because we have designed the API first, the tests can be designed while the code is being developed. In a way, we also have TDD (Test Driven Design) when using API first development.
+API๋ฅผ ๋จผ์ ์ค๊ณํ๊ธฐ ๋๋ฌธ์ ์ฝ๋๊ฐ ๊ฐ๋ฐ๋๋ ๋์ ํ
์คํธ๋ฅผ ์ค๊ณํ ์ ์์ต๋๋ค. ์ด๋ค ๋ฉด์์๋ API ํผ์คํธ ๊ฐ๋ฐ ๋ฐฉ์์ ์ฌ์ฉํ ๋ TDD(Test Driven Design)๋ฅผ ์ ์ฉํ๋ค๊ณ ๋ณผ ์ ์์ต๋๋ค.
### HTTP status codes
@@ -337,137 +336,137 @@ Because we have designed the API first, the tests can be designed while the code
-The response codes for HTTP are divided into five categories:
+HTTP์ ์๋ต ์ฝ๋๋ 5๊ฐ์ง ์นดํ
๊ณ ๋ฆฌ๋ก ๋๋์ด์ง๋๋ค.
-Informational (100-199)
-Success (200-299)
-Redirection (300-399)
-Client Error (400-499)
-Server Error (500-599)
+Informational (100-199)
+Success (200-299)
+Redirection (300-399)
+Client Error (400-499)
+Server Error (500-599)
### What does API gateway do?
-The diagram below shows the details.
+์๋ ๋ค์ด์ด๊ทธ๋จ์ ์์ธํ ๋ด์ฉ์ ๋ณด์ฌ์ค๋๋ค.
-Step 1 - The client sends an HTTP request to the API gateway.
+1๋จ๊ณ - ํด๋ผ์ด์ธํธ๊ฐ API ๊ฒ์ดํธ์จ์ด์ HTTP ์์ฒญ์ ๋ณด๋
๋๋ค.
-Step 2 - The API gateway parses and validates the attributes in the HTTP request.
+2๋จ๊ณ - API ๊ฒ์ดํธ์จ์ด๊ฐ HTTP ์์ฒญ์ ์ดํธ๋ฆฌ๋ทฐํธ๋ฅผ ํ์ฑํ๊ณ ์ ํจ์ฑ์ ๊ฒ์ฌํฉ๋๋ค.
-Step 3 - The API gateway performs allow-list/deny-list checks.
+3๋จ๊ณ - API ๊ฒ์ดํธ์จ์ด๊ฐ allow-list/deny-list ๊ฒ์ฌ๋ฅผ ์ํํฉ๋๋ค.
-Step 4 - The API gateway talks to an identity provider for authentication and authorization.
+4๋จ๊ณ - API ๊ฒ์ดํธ์จ์ด๊ฐ ์ธ์ฆ๊ณผ ์ธ๊ฐ๋ฅผ ์ํด ID ๊ณต๊ธ์์ ํต์ ํฉ๋๋ค.
-Step 5 - The rate limiting rules are applied to the request. If it is over the limit, the request is rejected.
+5๋จ๊ณ - ์์ฒญ์ ๋ ์ดํธ ๋ฆฌ๋ฏธํธ ๊ท์น์ ์ ์ฉํฉ๋๋ค. ํ๋๋ฅผ ์ด๊ณผํ๋ฉด ์์ฒญ์ ๊ฑฐ๋ถํฉ๋๋ค.
-Steps 6 and 7 - Now that the request has passed basic checks, the API gateway finds the relevant service to route to by path matching.
+6,7๋จ๊ณ - ์์ฒญ์ด ๊ธฐ๋ณธ ๊ฒ์ฌ๋ฅผ ํต๊ณผํ์ผ๋ฏ๋ก ์ด์ API ๊ฒ์ดํธ์จ์ด๊ฐ path ๋งค์นญ์ ํตํด ๋ผ์ฐํ
ํ ๊ด๋ จ ์๋น์ค๋ฅผ ์ฐพ์ต๋๋ค.
-Step 8 - The API gateway transforms the request into the appropriate protocol and sends it to backend microservices.
+8๋จ๊ณ - API ๊ฒ์ดํธ์จ์ด๊ฐ ์์ฒญ์ ์ ์ ํ ํ๋กํ ์ฝ๋ก ๋ณํํ์ฌ ๋ฐฑ์๋ ๋ง์ดํฌ๋ก์๋น์ค๋ก ์ ์กํฉ๋๋ค.
-Steps 9-12: The API gateway can handle errors properly, and deals with faults if the error takes a longer time to recover (circuit break). It can also leverage ELK (Elastic-Logstash-Kibana) stack for logging and monitoring. We sometimes cache data in the API gateway.
+9-12๋จ๊ณ: API ๊ฒ์ดํธ์จ์ด๋ ์ค๋ฅ๋ฅผ ์ ์ ํ๊ฒ ์ฒ๋ฆฌํ๊ณ , ๋ณต๊ตฌํ๋ ๋ฐ ์๊ฐ์ด ์ค๋ ๊ฑธ๋ฆฌ๋ ์ค๋ฅ๊ฐ ๋ฐ์ํ๋ ๊ฒฝ์ฐ ์ฅ์ ๋ฅผ ์ฒ๋ฆฌํฉ๋๋ค.(circuit break) ๋ํ ๋ก๊น
๊ณผ ๋ชจ๋ํฐ๋ง์ ์ํด ELK(Elastic-Logstash-Kibana) ์คํ์ ํ์ฉํ ์ ์์ต๋๋ค. ๋๋๋ก API ๊ฒ์ดํธ์จ์ด์ ๋ฐ์ดํฐ๋ฅผ ์บ์ํ๊ธฐ๋ ํฉ๋๋ค.
### How do we design effective and safe APIs?
-The diagram below shows typical API designs with a shopping cart example.
+์๋ ๋ค์ด์ด๊ทธ๋จ์ ์ผํ ์นดํธ ์์์ ํจ๊ป ์ผ๋ฐ์ ์ธ API ์ค๊ณ๋ฅผ ๋ณด์ฌ์ค๋๋ค.
-Note that API design is not just URL path design. Most of the time, we need to choose the proper resource names, identifiers, and path patterns. It is equally important to design proper HTTP header fields or to design effective rate-limiting rules within the API gateway.
+API ์ค๊ณ๋ ๋จ์ํ URL path ์ค๊ณ๊ฐ ์๋๋ผ๋ ์ ์ ์ ์ํ์ธ์. ๋๋ถ๋ถ์ ๊ฒฝ์ฐ ์ ์ ํ ๋ฆฌ์์ค ์ด๋ฆ, ์๋ณ์, path ํจํด์ ์ ํํด์ผ ํฉ๋๋ค. ์ ์ ํ HTTP ํค๋ ํ๋๋ฅผ ์ค๊ณํ๊ฑฐ๋ API ๊ฒ์ดํธ์จ์ด ๋ด์์ ํจ๊ณผ์ ์ธ rate limit ๊ท์น์ ์ค๊ณํ๋ ๊ฒ๋ ๋ง์ฐฌ๊ฐ์ง๋ก ์ค์ํฉ๋๋ค.
### TCP/IP encapsulation
-How is data sent over the network? Why do we need so many layers in the OSI model?
+๋ฐ์ดํฐ๋ ๋คํธ์ํฌ๋ฅผ ํตํด ์ด๋ป๊ฒ ์ ์ก๋๋์? OSI ๋ชจ๋ธ์ ๋ง์ ๊ณ์ธต์ด ํ์ํ ์ด์ ๋ ๋ฌด์์ธ๊ฐ์?
-The diagram below shows how data is encapsulated and de-encapsulated when transmitting over the network.
+์๋ ๋ค์ด์ด๊ทธ๋จ์ ๋คํธ์ํฌ๋ฅผ ํตํด ๋ฐ์ดํฐ๋ฅผ ์ ์กํ ๋ ์ด๋ป๊ฒ ์บก์ํ๋๊ณ ์บก์ํ๊ฐ ํด์ ๋๋์ง ๋ณด์ฌ์ค๋๋ค.
-Step 1: When Device A sends data to Device B over the network via the HTTP protocol, it is first added an HTTP header at the application layer.
+1๋จ๊ณ: ๋๋ฐ์ด์ค A๊ฐ ๋คํธ์ํฌ์์ HTTP ํ๋กํ ์ฝ์ ํตํด ์ฅ์น B๋ก ๋ฐ์ดํฐ๋ฅผ ์ ์กํ ๋, ๋จผ์ ์์ฉ ๊ณ์ธต์์ HTTP ํค๋๊ฐ ์ถ๊ฐ๋ฉ๋๋ค.
-Step 2: Then a TCP or a UDP header is added to the data. It is encapsulated into TCP segments at the transport layer. The header contains the source port, destination port, and sequence number.
+2๋จ๊ณ: ๊ทธ๋ฐ ๋ค์ TCP ํน์ UDP ํค๋๊ฐ ๋ฐ์ดํฐ์ ์ถ๊ฐ๋ฉ๋๋ค. ์ด ํค๋๋ ์ ์ก ๊ณ์ธต์์ TCP ์ธ๊ทธ๋จผํธ๋ก ์บก์ํ๋ฉ๋๋ค. ํค๋์๋ ์์ค ํฌํธ, ๋ฐ์คํฐ๋ค์ด์
ํฌํธ, ์ํ์ค ๋๋ฒ๊ฐ ํฌํจ๋ฉ๋๋ค.
-Step 3: The segments are then encapsulated with an IP header at the network layer. The IP header contains the source/destination IP addresses.
+3๋จ๊ณ: ๊ทธ๋ฐ ๋ค์ ์ธ๊ทธ๋จผํธ๋ ๋คํธ์ํฌ ๊ณ์ธต์์ IP ํค๋๋ก ์บก์ํ๋ฉ๋๋ค. IP ํค๋์๋ ์์ค/๋ฐ์คํฐ๋ค์ด์
IP ์ฃผ์๊ฐ ํฌํจ๋ฉ๋๋ค.
-Step 4: The IP datagram is added a MAC header at the data link layer, with source/destination MAC addresses.
+4๋จ๊ณ: ๋ฐ์ดํฐ ๋งํฌ ๊ณ์ธต์์ IP ๋ฐ์ดํฐ๊ทธ๋จ์ ์์ค/๋ฐ์คํฐ๋ค์ด์
MAC ์ฃผ์์ ํจ๊ป MAC ํค๋๊ฐ ์ถ๊ฐ๋ฉ๋๋ค.
-Step 5: The encapsulated frames are sent to the physical layer and sent over the network in binary bits.
+5๋จ๊ณ: ์บก์ํ๋ ํ๋ ์์ด ๋ฌผ๋ฆฌ ๊ณ์ธต์ผ๋ก ์ ์ก๋๊ณ ๋คํธ์ํฌ๋ฅผ ํตํด 2์ง์ ๋นํธ๋ก ์ ์ก๋ฉ๋๋ค.
-Steps 6-10: When Device B receives the bits from the network, it performs the de-encapsulation process, which is a reverse processing of the encapsulation process. The headers are removed layer by layer, and eventually, Device B can read the data.
+6-10๋จ๊ณ: ๋๋ฐ์ด์ค B๊ฐ ๋คํธ์ํฌ์์ ๋นํธ๋ฅผ ์์ ํ๋ฉด ์บก์ํ ํ๋ก์ธ์ค์ ์ญ์ฒ๋ฆฌ์ธ ์บก์ํ ํด์ ํ๋ก์ธ์ค๋ฅผ ์ํํฉ๋๋ค. ํค๋๊ฐ ํ ์ธต์ฉ ์ ๊ฑฐ๋๊ณ ๊ฒฐ๊ตญ ๋๋ฐ์ด์ค B๊ฐ ๋ฐ์ดํฐ๋ฅผ ์ฝ์ ์ ์๊ฒ ๋ฉ๋๋ค.
-We need layers in the network model because each layer focuses on its own responsibilities. Each layer can rely on the headers for processing instructions and does not need to know the meaning of the data from the last layer.
+๋คํธ์ํฌ ๋ชจ๋ธ์ ๊ณ์ธต์ด ํ์ํ ์ด์ ๋ ๊ฐ ๊ณ์ธต์ด ๊ณ ์ ํ ์ฑ
์์ ์ง์คํ๊ธฐ ๋๋ฌธ์
๋๋ค. ๊ฐ ๊ณ์ธต์ ์ฒ๋ฆฌ ์ง์นจ์ ํค๋์ ์์กดํ ์ ์์ผ๋ฉฐ ๋ง์ง๋ง ๊ณ์ธต์ ๋ฐ์ดํฐ์ ์๋ฏธ๋ฅผ ์ ํ์๊ฐ ์์ต๋๋ค.
### Why is Nginx called a โreverseโ proxy?
-The diagram below shows the differences between a ๐๐จ๐ซ๐ฐ๐๐ซ๐ ๐ฉ๐ซ๐จ๐ฑ๐ฒ and a ๐ซ๐๐ฏ๐๐ซ๐ฌ๐ ๐ฉ๐ซ๐จ๐ฑ๐ฒ.
+์๋ ๋ค์ด์ด๊ทธ๋จ์ ๐๐จ๐ซ๐ฐ๐๐ซ๐ ๐ฉ๐ซ๐จ๐ฑ๐ฒ ์ ๐ซ๐๐ฏ๐๐ซ๐ฌ๐ ๐ฉ๐ซ๐จ๐ฑ๐ฒ ์ ์ฐจ์ด์ ์ ๋ณด์ฌ์ค๋๋ค.
-A forward proxy is a server that sits between user devices and the internet.
+ํฌ์๋ ํ๋ก์๋ ์ฌ์ฉ์ ๋๋ฐ์ด์ค์ ์ธํฐ๋ท ์ฌ์ด์ ์๋ ์๋ฒ์
๋๋ค.
-A forward proxy is commonly used for:
+ํฌ์๋ ํ๋ก์๋ ์ผ๋ฐ์ ์ผ๋ก ๋ค์ ์ฉ๋๋ก ์ฌ์ฉ๋ฉ๋๋ค.
-1. Protecting clients
-2. Circumventing browsing restrictions
-3. Blocking access to certain content
+1. ํด๋ผ์ด์ธํธ ๋ณดํธ
+2. ๋ธ๋ผ์ฐ์ง ์ ์ฝ ์ฐํํ๊ธฐ
+3. ํน์ ์ฝํ
์ธ ์ ๋ํ ์ก์ธ์ค ์ฐจ๋จ
-A reverse proxy is a server that accepts a request from the client, forwards the request to web servers, and returns the results to the client as if the proxy server had processed the request.
+๋ฆฌ๋ฒ์ค ํ๋ก์๋ ํด๋ผ์ด์ธํธ์ ์์ฒญ์ ์๋ฝํ์ฌ ์น ์๋ฒ๋ก ์์ฒญ์ ์ ๋ฌํ ํ ํ๋ก์ ์๋ฒ๊ฐ ์์ฒญ์ ์ฒ๋ฆฌํ ๊ฒ์ฒ๋ผ ๊ฒฐ๊ณผ๋ฅผ ํด๋ผ์ด์ธํธ์ ๋ฐํํ๋ ์๋ฒ์
๋๋ค.
-A reverse proxy is good for:
+๋ฆฌ๋ฒ์ค ํ๋ก์๋ ๋ค์๊ณผ ๊ฐ์ ๊ฒฝ์ฐ์ ์ ์ฉํฉ๋๋ค.
-1. Protecting servers
-2. Load balancing
-3. Caching static contents
-4. Encrypting and decrypting SSL communications
+1. ์๋ฒ ๋ณดํธ
+2. ๋ก๋ ๋ฐธ๋ฐ์ฑ
+3. ์ ์ ์ฝํ
์ธ ์บ์ฑ
+4. SSL ํต์ ์ํธํ ๋ฐ ๋ณตํธํ
### What are the common load-balancing algorithms?
-The diagram below shows 6 common algorithms.
+์๋ ๋ค์ด์ด๊ทธ๋จ์ 6๊ฐ์ง ์ผ๋ฐ์ ์ธ ์๊ณ ๋ฆฌ์ฆ์ ๋ณด์ฌ์ค๋๋ค.
-- Static Algorithms
+- ์ ์ ์๊ณ ๋ฆฌ์ฆ
1. Round robin
- The client requests are sent to different service instances in sequential order. The services are usually required to be stateless.
+ ํด๋ผ์ด์ธํธ ์์ฒญ์ ์์ฐจ์ ์ผ๋ก ๋ค๋ฅธ ์๋น์ค ์ธ์คํด์ค๋ก ์ ์ก๋ฉ๋๋ค. ์๋น์ค๋ ์ผ๋ฐ์ ์ผ๋ก ์คํ
์ดํธ๋ฆฌ์ค(๊ณผ๊ฑฐ ์ฒ๋ฆฌ ๋ด์ฉ์ ๊ธฐ์ตํ์ง ์๋ ์๋น์ค)์ฌ์ผ ํฉ๋๋ค.
3. Sticky round-robin
- This is an improvement of the round-robin algorithm. If Aliceโs first request goes to service A, the following requests go to service A as well.
+ ์ด๋ ๋ผ์ด๋ ๋ก๋น ์๊ณ ๋ฆฌ์ฆ์ ๊ฐ์ ํ ๊ฒ์
๋๋ค. ์จ๋ฆฌ์ค์ ์ฒซ ๋ฒ์งธ ์์ฒญ์ด ์๋น์ค A๋ก ์ ๋ฌ๋๋ฉด ๋ค์ ์์ฒญ๋ ์๋น์ค A๋ก ์ ๋ฌ๋ฉ๋๋ค.
4. Weighted round-robin
- The admin can specify the weight for each service. The ones with a higher weight handle more requests than others.
+ ๊ด๋ฆฌ์๋ ๊ฐ ์๋น์ค์ ๋ํ ๊ฐ์ค์น๋ฅผ ์ง์ ํ ์ ์์ต๋๋ค. ๊ฐ์ค์น๊ฐ ๋์ ์๋น์ค๋ ๋ค๋ฅธ ์๋น์ค๋ณด๋ค ๋ ๋ง์ ์์ฒญ์ ์ฒ๋ฆฌํฉ๋๋ค.
6. Hash
- This algorithm applies a hash function on the incoming requestsโ IP or URL. The requests are routed to relevant instances based on the hash function result.
+ ์ด ์๊ณ ๋ฆฌ์ฆ์ ๋ค์ด์ค๋ ์์ฒญ์ IP ๋๋ URL์ ํด์ ํจ์๋ฅผ ์ ์ฉํฉ๋๋ค. ์์ฒญ์ ํด์ ํจ์ ๊ฒฐ๊ณผ์ ๋ฐ๋ผ ๊ด๋ จ ์ธ์คํด์ค๋ก ๋ผ์ฐํ
๋ฉ๋๋ค.
-- Dynamic Algorithms
+- ๋์ ์๊ณ ๋ฆฌ์ฆ
5. Least connections
- A new request is sent to the service instance with the least concurrent connections.
+ ๋์ ์ฐ๊ฒฐ์ด ๊ฐ์ฅ ์ ์ ์๋น์ค ์ธ์คํด์ค๋ก ์ ์์ฒญ์ด ์ ์ก๋ฉ๋๋ค.
7. Least response time
- A new request is sent to the service instance with the fastest response time.
+ ์ ์์ฒญ์ ์๋ต ์๊ฐ์ด ๊ฐ์ฅ ๋น ๋ฅธ ์๋น์ค ์ธ์คํด์ค๋ก ์ ์ก๋ฉ๋๋ค.
### URL, URI, URN - Do you know the differences?
-The diagram below shows a comparison of URL, URI, and URN.
+์๋ ๋ค์ด์ด๊ทธ๋จ์ URL, URI, URN์ ๋น๊ต๋ฅผ ๋ณด์ฌ์ค๋๋ค.
@@ -475,20 +474,20 @@ The diagram below shows a comparison of URL, URI, and URN.
- URI
-URI stands for Uniform Resource Identifier. It identifies a logical or physical resource on the web. URL and URN are subtypes of URI. URL locates a resource, while URN names a resource.
+URI์ Uniform Resource Identifier์ ์ฝ์์
๋๋ค. ์น์์ ๋
ผ๋ฆฌ์ ๋๋ ๋ฌผ๋ฆฌ์ ๋ฆฌ์์ค๋ฅผ ์๋ณํฉ๋๋ค. URL๊ณผ URN์ URI์ ํ์ ์ ํ์
๋๋ค. URL์ ๋ฆฌ์์ค๋ฅผ ์ฐพ๊ณ URN์ ๋ฆฌ์์ค์ ์ด๋ฆ์ ์ง์ ํฉ๋๋ค.
-A URI is composed of the following parts:
+URI๋ ๋ค์๊ณผ ๊ฐ์ ๋ถ๋ถ์ผ๋ก ๊ตฌ์ฑ๋์ด ์์ต๋๋ค.
scheme:[//authority]path[?query][#fragment]
- URL
-URL stands for Uniform Resource Locator, the key concept of HTTP. It is the address of a unique resource on the web. It can be used with other protocols like FTP and JDBC.
+URL์ Uniform Resource Locator์ ์ฝ์๋ก, HTTP์ ํต์ฌ ๊ฐ๋
์
๋๋ค. ์น์์ ๊ณ ์ ํ ๋ฆฌ์์ค์ ์ฃผ์์
๋๋ค. FTP์ JDBC์ ๊ฐ์ ๋ค๋ฅธ ํ๋กํ ์ฝ๊ณผ ํจ๊ป ์ฌ์ฉํ ์ ์์ต๋๋ค.
- URN
-URN stands for Uniform Resource Name. It uses the urn scheme. URNs cannot be used to locate a resource. A simple example given in the diagram is composed of a namespace and a namespace-specific string.
+URN์ Uniform Resource Name์ ์ฝ์๋ก, urn ์คํค๋ง๋ฅผ ์ฌ์ฉํฉ๋๋ค. URN์ ๋ฆฌ์์ค๋ฅผ ์ฐพ๋ ๋ฐ ์ฌ์ฉํ ์ ์์ต๋๋ค. ๋ค์ด์ด๊ทธ๋จ์ ์ ์๋ ๊ฐ๋จํ ์๋ ๋ค์์คํ์ด์ค์ ๋ค์์คํ์ด์ค ํน์ ๋ฌธ์์ด๋ก ๊ตฌ์ฑ๋์ด ์์ต๋๋ค.
-If you would like to learn more detail on the subject, I would recommend [W3Cโs clarification](https://www.w3.org/TR/uri-clarification/).
+์ด ์ฃผ์ ์ ๋ํด ๋ ์์ธํ ์์๋ณด๋ ค๋ฉด ๋ค์์ ์ถ์ฒํฉ๋๋ค. [W3Cโs clarification](https://www.w3.org/TR/uri-clarification/).
## CI/CD
From c20676074b5b5d71efbc03cf3f7b52b7337bf1cd Mon Sep 17 00:00:00 2001
From: Deadintegral
Date: Sun, 28 Jan 2024 14:03:23 +0900
Subject: [PATCH 04/16] docs: translate CICD
---
translations/README-kr.md | 48 +++++++++++++++++++--------------------
1 file changed, 24 insertions(+), 24 deletions(-)
diff --git a/translations/README-kr.md b/translations/README-kr.md
index 4e018bb..856a119 100644
--- a/translations/README-kr.md
+++ b/translations/README-kr.md
@@ -12,7 +12,7 @@
ใ
-
+
# System Design 101
@@ -497,28 +497,28 @@ URN์ Uniform Resource Name์ ์ฝ์๋ก, urn ์คํค๋ง๋ฅผ ์ฌ์ฉํฉ๋๋ค. URN
-Section 1 - SDLC with CI/CD
+์น์
1 - CI/CD๊ฐ ํฌํจ๋ ์ํํธ์จ์ด ๊ฐ๋ฐ ์๋ช
์ฃผ๊ธฐ
-The software development life cycle (SDLC) consists of several key stages: development, testing, deployment, and maintenance. CI/CD automates and integrates these stages to enable faster and more reliable releases.
+์ํํธ์จ์ด ๊ฐ๋ฐ ์๋ช
์ฃผ๊ธฐ(SDLC)๋ ๊ฐ๋ฐ, ํ
์คํธ, ๋ฐฐํฌ, ์ ์ง ๊ด๋ฆฌ ๋ฑ ๋ช ๊ฐ์ง ์ฃผ์ ๋จ๊ณ๋ก ๊ตฌ์ฑ๋ฉ๋๋ค. CI/CD๋ ์ด๋ฌํ ๋จ๊ณ๋ฅผ ์๋ํํ๊ณ ํตํฉํ์ฌ ๋ ๋น ๋ฅด๊ณ ์์ ์ ์ธ ๋ฆด๋ฆฌ์ค๋ฅผ ๊ฐ๋ฅํ๊ฒ ํฉ๋๋ค.
-When code is pushed to a git repository, it triggers an automated build and test process. End-to-end (e2e) test cases are run to validate the code. If tests pass, the code can be automatically deployed to staging/production. If issues are found, the code is sent back to development for bug fixing. This automation provides fast feedback to developers and reduces the risk of bugs in production.
+์ฝ๋๊ฐ git ๋ฆฌํฌ์งํ ๋ฆฌ์ ํธ์๋๋ฉด ์๋ํ๋ ๋น๋ ๋ฐ ํ
์คํธ ํ๋ก์ธ์ค๊ฐ ์์๋ฉ๋๋ค. ์ฝ๋์ ์ ํจ์ฑ์ ๊ฒ์ฌํ๊ธฐ ์ํด ์๋ํฌ์๋(e2e) ํ
์คํธ ์ผ์ด์ค๊ฐ ์คํ๋ฉ๋๋ค. ํ
์คํธ๋ฅผ ํต๊ณผํ๋ฉด ์ฝ๋๋ฅผ ์คํ
์ด์ง/ํ๋ก๋์
ํ๊ฒฝ์ ์๋์ผ๋ก ๋ฐฐํฌํ ์ ์์ต๋๋ค. ์ด์๊ฐ ๋ฐ๊ฒฌ๋๋ฉด ์ฝ๋๋ ๋ฒ๊ทธ ์์ ์ ์ํด ๊ฐ๋ฐ ๋จ๊ณ๋ก ๋ค์ ๋ณด๋ด์ง๋๋ค. ์ด๋ฌํ ์๋ํ๋ ๊ฐ๋ฐ์์๊ฒ ์ ์ํ ํผ๋๋ฐฑ์ ์ ๊ณตํ๊ณ ํ๋ก๋์
ํ๊ฒฝ์์ ๋ฐ์ํ๋ ๋ฒ๊ทธ ์ํ์ ์ค์ฌ์ค๋๋ค.
-Section 2 - Difference between CI and CD
+์น์
2 - CI์ CD์ ์ฐจ์ด์
-Continuous Integration (CI) automates the build, test, and merge process. It runs tests whenever code is committed to detect integration issues early. This encourages frequent code commits and rapid feedback.
+Continuous Integration(CI)์ ๋น๋, ํ
์คํธ, ๋ณํฉ ํ๋ก์ธ์ค๋ฅผ ์๋ํํฉ๋๋ค. ์ฝ๋๊ฐ ์ปค๋ฐ๋ ๋๋ง๋ค ํ
์คํธ๋ฅผ ์คํํ์ฌ ํตํฉ ์ด์๋ฅผ ์กฐ๊ธฐ์ ๋ฐ๊ฒฌํฉ๋๋ค. ์ด๋ฅผ ํตํด ์ฝ๋ ์ปค๋ฐ์ ์์ฃผ ํ๊ณ ํผ๋๋ฐฑ์ ๋น ๋ฅด๊ฒ ๋ฐ์ ์ ์์ต๋๋ค.
-Continuous Delivery (CD) automates release processes like infrastructure changes and deployment. It ensures software can be released reliably at any time through automated workflows. CD may also automate the manual testing and approval steps required before production deployment.
+Continuous Delivery(CD)๋ ์ธํ๋ผ ๋ณ๊ฒฝ, ๋ฐฐํฌ์ ๊ฐ์ ๋ฆด๋ฆฌ์ค ํ๋ก์ธ์ค๋ฅผ ์๋ํํฉ๋๋ค. ์๋ํ๋ ์ํฌํ๋ก๋ฅผ ํตํด ์ธ์ ๋ ์ง ์ํํธ์จ์ด๋ฅผ ์์ ์ ์ผ๋ก ๋ฆด๋ฆฌ์คํ ์ ์์ต๋๋ค. ๋ํ CD๋ ํ๋ก๋์
๋ฐฐํฌ ์ ์ ํ์ํ ๋ฉ๋ด์ผ ํ
์คํธ์ ์น์ธ ๋จ๊ณ๋ฅผ ์๋ํํ ์๋ ์์ต๋๋ค.
-Section 3 - CI/CD Pipeline
+์น์
3 - CI/CD ํ์ดํ๋ผ์ธ
-A typical CI/CD pipeline has several connected stages:
-- The developer commits code changes to the source control
-- CI server detects changes and triggers the build
-- Code is compiled, and tested (unit, integration tests)
-- Test results reported to the developer
-- On success, artifacts are deployed to staging environments
-- Further testing may be done on staging before release
-- CD system deploys approved changes to production
+์ผ๋ฐ์ ์ธ CI/CD ํ์ดํ๋ผ์ธ์ ๋ค์๊ณผ ๊ฐ์ด ์ฐ๊ฒฐ๋ ์ฌ๋ฌ ๋จ๊ณ๋ก ๊ตฌ์ฑ๋ฉ๋๋ค.
+- ๊ฐ๋ฐ์๊ฐ ์ฝ๋ ๋ณ๊ฒฝ ์ฌํญ์ ์์ค ์ปจํธ๋กค์ ์ปค๋ฐํฉ๋๋ค.
+- CI ์๋ฒ๊ฐ ๋ณ๊ฒฝ ์ฌํญ์ ๊ฐ์งํ๊ณ ๋น๋๋ฅผ ํธ๋ฆฌ๊ฑฐํฉ๋๋ค.
+- ์ฝ๋๊ฐ ์ปดํ์ผ๋๊ณ ํ
์คํธ๋ฉ๋๋ค(๋จ์ ํ
์คํธ, ํตํฉ ํ
์คํธ).
+- ํ
์คํธ ๊ฒฐ๊ณผ๋ฅผ ๊ฐ๋ฐ์์๊ฒ ๋ณด๊ณ ๋ฉ๋๋ค.
+- ์ฑ๊ณตํ๋ฉด ์ํฐํฉํธ๊ฐ ์คํ
์ด์ง ํ๊ฒฝ์ ๋ฐฐํฌ๋ฉ๋๋ค.
+- ๋ฆด๋ฆฌ์ค ์ ์ ์คํ
์ด์ง ํ๊ฒฝ์์ ์ถ๊ฐ ํ
์คํธ๋ฅผ ์ํํ ์ ์์ต๋๋ค.
+- CD ์์คํ
์ด ์น์ธํ ๋ณ๊ฒฝ ์ฌํญ์ ํ๋ก๋์
์ ๋ฐฐํฌํฉ๋๋ค.
### Netflix Tech Stack (CI/CD Pipeline)
@@ -526,21 +526,21 @@ A typical CI/CD pipeline has several connected stages:
-Planning: Netflix Engineering uses JIRA for planning and Confluence for documentation.
+ํ๋๋: ๋ทํ๋ฆญ์ค ์์ง๋์ด๋ง์ ํ๋๋์๋ JIRA๋ฅผ, ๋ฌธ์ํ์๋ Confluence๋ฅผ ์ฌ์ฉํฉ๋๋ค.
-Coding: Java is the primary programming language for the backend service, while other languages are used for different use cases.
+์ฝ๋ฉ: Java๋ ๋ฐฑ์๋ ์๋น์ค๋ฅผ ์ํ ๊ธฐ๋ณธ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์ด๋ฉฐ, ๋ค๋ฅธ ์ธ์ด๋ ์ ์ฆ์ผ์ด์ค์ ๋ฐ๋ผ ์ฌ์ฉ๋ฉ๋๋ค.
-Build: Gradle is mainly used for building, and Gradle plugins are built to support various use cases.
+๋น๋: Gradle์ ์ฃผ๋ก ๋น๋์ ์ฌ์ฉ๋๋ฉฐ, Gradle ํ๋ฌ๊ทธ์ธ์ ๋ค์ํ ์ ์ค์ผ์ด์ค๋ฅผ ์ง์ํ๊ธฐ ์ํด ๋ง๋ค์ด์ก์ต๋๋ค.
-Packaging: Package and dependencies are packed into an Amazon Machine Image (AMI) for release.
+ํจํค์ง: ํจํค์ง ๋ฐ ์์กด์ฑ์ ๋ฆด๋ฆฌ์ค๋ฅผ ์ํด ์๋ง์กด ๋จธ์ ์ด๋ฏธ์ง(AMI)์ ํจํค์ง๋ฉ๋๋ค.
-Testing: Testing emphasizes the production culture's focus on building chaos tools.
+ํ
์คํ
: Testing emphasizes the production culture's focus on building chaos tools.
-Deployment: Netflix uses its self-built Spinnaker for canary rollout deployment.
+๋ฐฐํฌ: ๋ทํ๋ฆญ์ค๋ ์นด๋๋ฆฌ ๋กค์์ ๋ฐฐํฌ์ ์์ฒด ๊ตฌ์ถํ Spinnaker๋ฅผ ์ฌ์ฉํฉ๋๋ค.
-Monitoring: The monitoring metrics are centralized in Atlas, and Kayenta is used to detect anomalies.
+๋ชจ๋ํฐ๋ง: ๋ชจ๋ํฐ๋ง ์งํ๋ Atlas์์ ์ค์ ์ง์ค์์ผ๋ก ๊ด๋ฆฌ๋๋ฉฐ, ์ด์ ์งํ๋ฅผ ๊ฐ์งํ๋ ๋ฐ Kayenta๊ฐ ์ฌ์ฉ๋ฉ๋๋ค.
-Incident report: Incidents are dispatched according to priority, and PagerDuty is used for incident handling.
+์ธ์๋ํธ ๋ฆฌํฌํธ: ์ฐ์ ์์์ ๋ฐ๋ผ ์ธ์๋ํธ๊ฐ ๋ฐ์ก๋๋ฉฐ, ์ฌ๊ณ ์ฒ๋ฆฌ๋ฅผ ์ํด PagerDuty๊ฐ ์ฌ์ฉ๋ฉ๋๋ค.
## Architecture patterns
From c2a9c79c6ad898ef2ae9a3cd4d7e2679f1591ee0 Mon Sep 17 00:00:00 2001
From: Deadintegral
Date: Sun, 28 Jan 2024 22:40:26 +0900
Subject: [PATCH 05/16] docs: translate to database cache
---
translations/README-kr.md | 146 +++++++++++++++++++-------------------
1 file changed, 73 insertions(+), 73 deletions(-)
diff --git a/translations/README-kr.md b/translations/README-kr.md
index 856a119..815d6b0 100644
--- a/translations/README-kr.md
+++ b/translations/README-kr.md
@@ -544,21 +544,21 @@ Continuous Delivery(CD)๋ ์ธํ๋ผ ๋ณ๊ฒฝ, ๋ฐฐํฌ์ ๊ฐ์ ๋ฆด๋ฆฌ์ค ํ๋ก
## Architecture patterns
-### MVC, MVP, MVVM, MVVM-C, and VIPER
-These architecture patterns are among the most commonly used in app development, whether on iOS or Android platforms. Developers have introduced them to overcome the limitations of earlier patterns. So, how do they differ?
+### MVC, MVP, MVVM, MVVM-C, VIPER
+์ด๋ฌํ ์ํคํ
์ฒ ํจํด์ iOS, Android ํ๋ซํผ์์ ์ฑ ๊ฐ๋ฐ ์ ๊ฐ์ฅ ์ผ๋ฐ์ ์ผ๋ก ์ฌ์ฉํ๋ ํจํด์
๋๋ค. ๊ฐ๋ฐ์๋ค์ ์ด์ ํจํด์ ํ๊ณ๋ฅผ ๊ทน๋ณตํ๊ธฐ ์ํด ์ด๋ฌํ ํจํด์ ๋์
ํ์ต๋๋ค. ๊ทธ๋ ๋ค๋ฉด ์ด๋ป๊ฒ ๋ค๋ฅผ๊น์?
-- MVC, the oldest pattern, dates back almost 50 years
-- Every pattern has a "view" (V) responsible for displaying content and receiving user input
-- Most patterns include a "model" (M) to manage business data
-- "Controller," "presenter," and "view-model" are translators that mediate between the view and the model ("entity" in the VIPER pattern)
+- ๊ฐ์ฅ ์ค๋๋ ํจํด์ธ MVC๋ ๊ฑฐ์ 50๋
์ ์ผ๋ก ๊ฑฐ์ฌ๋ฌ ์ฌ๋ผ๊ฐ๋๋ค.
+- ๋ชจ๋ ํจํด์๋ ์ฝํ
์ธ ๋ฅผ ํ์ํ๊ณ ์ฌ์ฉ์ ์
๋ ฅ์ ์์ ํ๋ 'view'(V)๊ฐ ์์ต๋๋ค.
+- ๋๋ถ๋ถ์ ํจํด์๋ ๋น์ฆ๋์ค ๋ฐ์ดํฐ๋ฅผ ๊ด๋ฆฌํ๊ธฐ ์ํ 'model'(M)์ด ํฌํจ๋ฉ๋๋ค.
+- "Controller", " presenter", "view-model"์ ๋ทฐ์ ๋ชจ๋ธ(VIPER ํจํด์ "entity") ์ฌ์ด๋ฅผ ๋งค๊ฐํ๋ ๋ณํ๊ธฐ์
๋๋ค.
### 18 Key Design Patterns Every Developer Should Know
-Patterns are reusable solutions to common design problems, resulting in a smoother, more efficient development process. They serve as blueprints for building better software structures. These are some of the most popular patterns:
+ํจํด์ ์ผ๋ฐ์ ์ธ ์ค๊ณ ๋ฌธ์ ์ ๋ํ ์ฌ์ฌ์ฉ ๊ฐ๋ฅํ ์๋ฃจ์
์ผ๋ก, ๋ณด๋ค ์ํํ๊ณ ํจ์จ์ ์ธ ๊ฐ๋ฐ ํ๋ก์ธ์ค๋ฅผ ๊ฐ๋ฅํ๊ฒ ํฉ๋๋ค. ํจํด์ ๋ ๋์ ์ํํธ์จ์ด ๊ตฌ์กฐ๋ฅผ ๊ตฌ์ถํ๊ธฐ ์ํ ์ฒญ์ฌ์ง ์ญํ ์ ํฉ๋๋ค. ๋ค์์ ๊ฐ์ฅ ๋ง์ด ์ฌ์ฉ๋๋ ํจํด ์ค ์ผ๋ถ์
๋๋ค.
@@ -591,83 +591,83 @@ Patterns are reusable solutions to common design problems, resulting in a smooth
-Choosing the right database for your project is a complex task. Many database options, each suited to distinct use cases, can quickly lead to decision fatigue.
+ํ๋ก์ ํธ์ ์ ํฉํ ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ฅผ ์ ํํ๋ ๊ฒ์ ๋ณต์กํ ์์
์
๋๋ค. ๊ฐ๊ธฐ ๋ค๋ฅธ ์ ์ฆ์ผ์ด์ค์ ์ ํฉํ ๋ฐ์ดํฐ๋ฒ ์ด์ค ์ต์
์ด ๋ง์ผ๋ฉด ์์ฌ ๊ฒฐ์ ์ ๋ํ ํผ๋ก๋๊ฐ ๋น ๋ฅด๊ฒ ๋์์ง ์ ์์ต๋๋ค.
-We hope this cheat sheet provides high-level direction to pinpoint the right service that aligns with your project's needs and avoid potential pitfalls.
+์ด ์นํธ์ํธ๊ฐ ํ๋ก์ ํธ์ ์๊ตฌ์ฌํญ์ ๋ง๋ ์ฌ๋ฐ๋ฅธ ์๋น์ค๋ฅผ ์ฐพ์๋ด๊ณ ์ ์ฌ์ ์ธ ํจ์ ์ ํผํ๋ ๋ฐ ๋์์ด ๋๊ธฐ๋ฅผ ๋ฐ๋๋๋ค.
-Note: Google has limited documentation for their database use cases. Even though we did our best to look at what was available and arrived at the best option, some of the entries may need to be more accurate.
+์ฐธ๊ณ : Google์ ๋ฐ์ดํฐ๋ฒ ์ด์ค ์ ์ฆ์ผ์ด์ค์ ๋ํ ๋ฌธ์๊ฐ ์ ํ๋์ด ์์ต๋๋ค. ์ฌ์ฉ ๊ฐ๋ฅํ ์๋ฃ๋ฅผ ์ต๋ํ ๊ฒํ ํ๊ณ ์ต์ ์ ์ต์
์ ์ ์ํ์ง๋ง, ์ผ๋ถ ํญ๋ชฉ์ ๋ ์ ํํ ์ ๋ณด๊ฐ ํ์ํ ์ ์์ต๋๋ค.
### 8 Data Structures That Power Your Databases
-The answer will vary depending on your use case. Data can be indexed in memory or on disk. Similarly, data formats vary, such as numbers, strings, geographic coordinates, etc. The system might be write-heavy or read-heavy. All of these factors affect your choice of database index format.
+์ ๋ต์ ์ ์ฆ์ผ์ด์ค์ ๋ฐ๋ผ ๋ฌ๋ผ์ง๋๋ค. ๋ฐ์ดํฐ๋ ๋ฉ๋ชจ๋ฆฌ๋ ๋์คํฌ์ ์ธ๋ฑ์ค๋ ์ ์์ต๋๋ค. ๋ง์ฐฌ๊ฐ์ง๋ก ๋ฐ์ดํฐ ํฌ๋งท๋ ๋๋ฒ, ์คํธ๋ง, ์ง๋ฆฌ์ ์ขํ ๋ฑ ๋ค์ํฉ๋๋ค. ์์คํ
์ด ์ฐ๊ธฐ ์ค์ฌ์ผ ์๋ ์๊ณ ์ฝ๊ธฐ ์ค์ฌ์ผ ์๋ ์์ต๋๋ค. ์ด๋ฌํ ๋ชจ๋ ์์๋ ๋ฐ์ดํฐ๋ฒ ์ด์ค ์ธ๋ฑ์ค ํฌ๋งท ์ ํ์ ์ํฅ์ ๋ฏธ์นฉ๋๋ค.
-The following are some of the most popular data structures used for indexing data:
+๋ค์์ ๋ฐ์ดํฐ ์ธ๋ฑ์ฑ์ ๊ฐ์ฅ ๋ง์ด ์ฌ์ฉ๋๋ ๋ช ๊ฐ์ง ๋ฐ์ดํฐ ๊ตฌ์กฐ์
๋๋ค.
-- Skiplist: a common in-memory index type. Used in Redis
-- Hash index: a very common implementation of the โMapโ data structure (or โCollectionโ)
-- SSTable: immutable on-disk โMapโ implementation
-- LSM tree: Skiplist + SSTable. High write throughput
-- B-tree: disk-based solution. Consistent read/write performance
-- Inverted index: used for document indexing. Used in Lucene
-- Suffix tree: for string pattern search
-- R-tree: multi-dimension search, such as finding the nearest neighbor
+- Skiplist: ์ผ๋ฐ์ ์ธ ์ธ๋ฉ๋ชจ๋ฆฌ ์ธ๋ฑ์ค ํ์
์ผ๋ก, Redis์์ ์ฌ์ฉ.
+- Hash index: "Map" ๋ฐ์ดํฐ ๊ตฌ์กฐ(๋๋ "Collection")์ ๋งค์ฐ ์ผ๋ฐ์ ์ธ ๊ตฌํ.
+- SSTable: ๋์คํฌ์ ์ด๋ฎคํฐ๋ธ 'Map' ๊ตฌํ
+- LSM tree: Skiplist + SSTable. ๋์ ์ฐ๊ธฐ ์ฒ๋ฆฌ๋.
+- B-tree: ๋์คํฌ ๊ธฐ๋ฐ ์๋ฃจ์
. ์ผ๊ด๋ ์ฝ๊ธฐ/์ฐ๊ธฐ ์ฑ๋ฅ.
+- Inverted index: ๋ํ๋จผํธ ์ธ๋ฑ์ฑ์ ์ฌ์ฉ. ๋ฃจ์ฌ์์ ์ฌ์ฉ.
+- Suffix tree: ์คํธ๋ง ํจํด ๊ฒ์.
+- R-tree: ๊ฐ์ฅ ๊ฐ๊น์ด ์ด์ ์ฐพ๊ธฐ์ ๊ฐ์ ๋ค์ฐจ์ ๊ฒ์.
### How is an SQL statement executed in the database?
-The diagram below shows the process. Note that the architectures for different databases are different, the diagram demonstrates some common designs.
+์๋ ๋ค์ด์ด๊ทธ๋จ์ ๊ทธ ๊ณผ์ ์ ๋ณด์ฌ์ค๋๋ค. ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ง๋ค ์ํคํ
์ฒ๊ฐ ๋ค๋ฅด์ง๋ง ์ด ๋ค์ด์ด๊ทธ๋จ์ ๋ช ๊ฐ์ง ์ผ๋ฐ์ ์ธ ์ค๊ณ๋ฅผ ๋ณด์ฌ์ค๋๋ค.
-Step 1 - A SQL statement is sent to the database via a transport layer protocol (e.g.TCP).
+1๋จ๊ณ - SQL ๋ฌธ์ ์ ์ก ๊ณ์ธต ํ๋กํ ์ฝ(์: TCP)์ ํตํด ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ก ์ ์ก๋ฉ๋๋ค.
-Step 2 - The SQL statement is sent to the command parser, where it goes through syntactic and semantic analysis, and a query tree is generated afterward.
+2๋จ๊ณ - SQL ๋ฌธ์ command parser๋ก ์ ์ก๋์ด ๊ตฌ๋ฌธ ๋ฐ ์๋ฏธ ๋ถ์์ ๊ฑฐ์น ํ ์ฟผ๋ฆฌ ํธ๋ฆฌ๊ฐ ์์ฑ๋ฉ๋๋ค.
-Step 3 - The query tree is sent to the optimizer. The optimizer creates an execution plan.
+3๋จ๊ณ - ์ฟผ๋ฆฌ ํธ๋ฆฌ๊ฐ optimizer๋ก ์ ์ก๋ฉ๋๋ค. optimizer๊ฐ ์คํ ๊ณํ์ ์์ฑํฉ๋๋ค.
-Step 4 - The execution plan is sent to the executor. The executor retrieves data from the execution.
+4๋จ๊ณ - ์คํ ๊ณํ์ด executor์๊ฒ ์ ์ก๋ฉ๋๋ค. executor๋ ์ต์คํ์
์์ ๋ฐ์ดํฐ๋ฅผ ๊ฒ์ํฉ๋๋ค.
-Step 5 - Access methods provide the data fetching logic required for execution, retrieving data from the storage engine.
+5๋จ๊ณ - Access methods๋ ์คํ์ ํ์ํ ๋ฐ์ดํฐ ํ์นญ ๋ก์ง์ ์ ๊ณตํ์ฌ ์คํ ๋ฆฌ์ง ์์ง์์ ๋ฐ์ดํฐ๋ฅผ ๊ฒ์ํฉ๋๋ค.
-Step 6 - Access methods decide whether the SQL statement is read-only. If the query is read-only (SELECT statement), it is passed to the buffer manager for further processing. The buffer manager looks for the data in the cache or data files.
+6๋จ๊ณ - Access methods๋ SQL ๋ฌธ์ ์ฝ๊ธฐ ์ ์ฉ ์ฌ๋ถ๋ฅผ ๊ฒฐ์ ํฉ๋๋ค. ์ฟผ๋ฆฌ๊ฐ ์ฝ๊ธฐ ์ ์ฉ์ธ ๊ฒฝ์ฐ(SELECT ๋ฌธ), ์ฟผ๋ฆฌ๋ ์ถ๊ฐ ์ฒ๋ฆฌ๋ฅผ ์ํด buffer manager์๊ฒ ์ ๋ฌ๋ฉ๋๋ค. buffer manager๋ ์บ์ ๋๋ ๋ฐ์ดํฐ ํ์ผ์์ ๋ฐ์ดํฐ๋ฅผ ์ฐพ์ต๋๋ค.
-Step 7 - If the statement is an UPDATE or INSERT, it is passed to the transaction manager for further processing.
+7๋จ๊ณ - UPDATE ํน์ INSERT ๋ฌธ์ธ ๊ฒฝ์ฐ, ์ถ๊ฐ ์ฒ๋ฆฌ๋ฅผ ์ํด transaction manager์๊ฒ ์ ๋ฌํฉ๋๋ค.
-Step 8 - During a transaction, the data is in lock mode. This is guaranteed by the lock manager. It also ensures the transactionโs ACID properties.
+8๋จ๊ณ - ํธ๋์ญ์
์ด ์งํ๋๋ ๋์ ๋ฐ์ดํฐ๋ ์ ๊ฒจ ์์ต๋๋ค. ์ด๋ lock manager์ ์ํด ๋ณด์ฅ๋ฉ๋๋ค. ๋ํ ํธ๋์ญ์
์ ACID ํ๋กํผํฐ๋ ๋ณด์ฅํฉ๋๋ค.
### CAP theorem
-The CAP theorem is one of the most famous terms in computer science, but I bet different developers have different understandings. Letโs examine what it is and why it can be confusing.
+CAP ์ ๋ฆฌ๋ ์ปดํจํฐ ๊ณผํ์์ ๊ฐ์ฅ ์ ๋ช
ํ ์ฉ์ด ์ค ํ๋์ด์ง๋ง ๊ฐ๋ฐ์๋ง๋ค ์ดํดํ๋ ๋ฐ๊ฐ ๋ค๋ฅผ ์ ์์ต๋๋ค. ์ด ์ฉ์ด๊ฐ ๋ฌด์์ด๋ฉฐ ์ ํผ๋์ค๋ฌ์ธ ์ ์๋์ง ์ดํด๋ณด๊ฒ ์ต๋๋ค.
-CAP theorem states that a distributed system can't provide more than two of these three guarantees simultaneously.
+CAP ์ ๋ฆฌ์ ๋ฐ๋ฅด๋ฉด ๋ถ์ฐ ์์คํ
์ ์ด ์ธ ๊ฐ์ง ๋ณด์ฅ ์ค ๋ ๊ฐ์ง ์ด์์ ๋์์ ์ ๊ณตํ ์ ์์ต๋๋ค.
-**Consistency**: consistency means all clients see the same data at the same time no matter which node they connect to.
+**Consistency**: ์ผ๊ด์ฑ์ด๋ ๋ชจ๋ ํด๋ผ์ด์ธํธ๊ฐ ์ด๋ ๋
ธ๋์ ์ฐ๊ฒฐํ๋ ๋์ผํ ๋ฐ์ดํฐ๋ฅผ ๋์์ ๋ณผ ์ ์๋ค๋ ์๋ฏธ์
๋๋ค.
-**Availability**: availability means any client that requests data gets a response even if some of the nodes are down.
+**Availability**: ๊ฐ์ฉ์ฑ์ด๋ ์ผ๋ถ ๋
ธ๋๊ฐ ๋ค์ด๋๋๋ผ๋ ๋ฐ์ดํฐ๋ฅผ ์์ฒญํ๋ ๋ชจ๋ ํด๋ผ์ด์ธํธ๊ฐ ์๋ต์ ๋ฐ๋๋ค๋ ์๋ฏธ์
๋๋ค.
-**Partition Tolerance**: a partition indicates a communication break between two nodes. Partition tolerance means the system continues to operate despite network partitions.
+**Partition Tolerance**: ํํฐ์
์ ๋ ๋
ธ๋ ๊ฐ์ ํต์ ๋จ์ ์ ๋ํ๋
๋๋ค. ํํฐ์
๋๋ ๋์ค๋ ์์คํ
์ด ๋คํธ์ํฌ ํํฐ์
์๋ ๋ถ๊ตฌํ๊ณ ๊ณ์ ์๋ํ ์ ์๋ ๋ฅ๋ ฅ์ ์๋ฏธํฉ๋๋ค.
-The โ2 of 3โ formulation can be useful, **but this simplification could be misleading**.
+"์
์ค ๋" ๊ณต์์ ์ ์ฉํ ์ ์์ง๋ง **์ด๋ฌํ ๋จ์ํ๋ ์คํด์ ์์ง๊ฐ ์์ต๋๋ค**.
-1. Picking a database is not easy. Justifying our choice purely based on the CAP theorem is not enough. For example, companies don't choose Cassandra for chat applications simply because it is an AP system. There is a list of good characteristics that make Cassandra a desirable option for storing chat messages. We need to dig deeper.
+1. ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ฅผ ์ ํํ๋ ๊ฒ์ ์ฝ์ง ์์ต๋๋ค. CAP ์ ๋ฆฌ๋ง์ผ๋ก ์ ํ์ ์ ๋นํํ๋ ๊ฒ์ ์ถฉ๋ถํ์ง ์์ต๋๋ค. ์๋ฅผ ๋ค์ด, ํ์ฌ์์ ๋จ์ํ AP ์์คํ
์ด๋ผ๋ ์ด์ ๋ง์ผ๋ก ์ฑํ
์ ํ๋ฆฌ์ผ์ด์
์ ์ํด Cassandra๋ฅผ ์ ํํ์ง๋ ์์ต๋๋ค. ์ฑํ
๋ฉ์์ง๋ฅผ ์ ์ฅํ๋ ๋ฐ ์์ด Cassandra๋ฅผ ๋ฐ๋์งํ ์ต์
์ผ๋ก ๋ง๋๋ ์ข์ ํน์ฑ ๋ชฉ๋ก์ด ์์ต๋๋ค. ๋ ๊น์ด ํ๊ณ ๋ค ํ์๊ฐ ์์ต๋๋ค.
-2. โCAP prohibits only a tiny part of the design space: perfect availability and consistency in the presence of partitions, which are rareโ. Quoted from the paper: CAP Twelve Years Later: How the โRulesโ Have Changed.
+2. "CAP๋ ๋์์ธ ๊ณต๊ฐ์ ๊ทนํ ์ผ๋ถ๋ถ, ์ฆ ํํฐ์
์ด ์์ ๋ ์๋ฒฝํ ๊ฐ์ฉ์ฑ๊ณผ ์ผ๊ด์ฑ์ ๋ณด์ฅํ๋ ๊ฒฝ์ฐ๋ ๋๋ญ
๋๋ค." ๋
ผ๋ฌธ์์ ์ธ์ฉ: CAP Twelve Years Later: How the "Rules" Have Changed.
-3. The theorem is about 100% availability and consistency. A more realistic discussion would be the trade-offs between latency and consistency when there is no network partition. See PACELC theorem for more details.
+3. ์ด ์ ๋ฆฌ๋ ์ฝ 100%์ ๊ฐ์ฉ์ฑ๊ณผ ์ผ๊ด์ฑ์ ์๋ฏธํฉ๋๋ค. ๋ณด๋ค ํ์ค์ ์ธ ๋
ผ์๋ ๋คํธ์ํฌ ํํฐ์
์ด ์์ ๋ ์ง์ฐ ์๊ฐ๊ณผ ์ผ๊ด์ฑ ๊ฐ์ ์ ์ถฉ์์
๋๋ค. ์์ธํ ๋ด์ฉ์ PACELC ์ ๋ฆฌ๋ฅผ ์ฐธ์กฐํ์ธ์.
**Is the CAP theorem actually useful?**
-I think it is still useful as it opens our minds to a set of tradeoff discussions, but it is only part of the story. We need to dig deeper when picking the right database.
+์ ์ถฉ์์ ๋
ผ์ํ ์ ์๋ค๋ ์ ์์ ์ฌ์ ํ ์ ์ฉํ๋ค๊ณ ์๊ฐํ์ง๋ง, ์ด๋ ์ผ๋ถ๋ถ์ผ ๋ฟ์
๋๋ค. ์ฌ๋ฐ๋ฅธ ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ฅผ ์ ํํ๋ ค๋ฉด ๋ ๊น์ด ํ๊ณ ๋ค์ด์ผ ํฉ๋๋ค.
### Types of Memory and Storage
@@ -682,68 +682,68 @@ I think it is still useful as it opens our minds to a set of tradeoff discussion
-SQL statements are executed by the database system in several steps, including:
+SQL ๋ฌธ์ ๋ฐ์ดํฐ๋ฒ ์ด์ค ์์คํ
์์ ๋ค์๊ณผ ๊ฐ์ ์ฌ๋ฌ ๋จ๊ณ๋ก ์คํ๋ฉ๋๋ค.
-- Parsing the SQL statement and checking its validity
-- Transforming the SQL into an internal representation, such as relational algebra
-- Optimizing the internal representation and creating an execution plan that utilizes index information
-- Executing the plan and returning the results
+- SQL๋ฌธ ํ์ฑ๊ณผ ์ ํจ์ฑ ๊ฒ์ฌ
+- SQL์ ๊ด๊ณ๋์(relational algebra) ๊ฐ์ ๋ด๋ถ ํํ์ผ๋ก ๋ณํ
+- ๋ด๋ถ ํํ์ ์ต์ ํํ๊ณ ์ธ๋ฑ์ค ์ ๋ณด๋ฅผ ํ์ฉํ๋ ์คํ ๊ณํ ์์ฑ
+- ๊ณํ ์คํ ๋ฐ ๊ฒฐ๊ณผ ๋ฐํ
-The execution of SQL is highly complex and involves many considerations, such as:
+SQL ์คํ์ ๋งค์ฐ ๋ณต์กํ๋ฉฐ ๋ค์๊ณผ ๊ฐ์ ๋ง์ ๊ณ ๋ ค ์ฌํญ์ ํฌํจํฉ๋๋ค.
-- The use of indexes and caches
-- The order of table joins
-- Concurrency control
-- Transaction management
+- ์ธ๋ฑ์ค ๋ฐ ์บ์ ์ฌ์ฉ
+- ํ
์ด๋ธ ์กฐ์ธ ์์
+- ๋์์ฑ ์ ์ด
+- ํธ๋์ญ์
๊ด๋ฆฌ
### SQL language
-In 1986, SQL (Structured Query Language) became a standard. Over the next 40 years, it became the dominant language for relational database management systems. Reading the latest standard (ANSI SQL 2016) can be time-consuming. How can I learn it?
+1986๋
, SQL(Structured Query Language)์ด ํ์ค์ด ๋์์ต๋๋ค. ๊ทธ ํ 40๋
๋์ ๊ด๊ณํ ๋ฐ์ดํฐ๋ฒ ์ด์ค ๊ด๋ฆฌ ์์คํ
์์ ๊ฐ์ฅ ๋ง์ด ์ฌ์ฉ๋๋ ์ธ์ด๊ฐ ๋์์ต๋๋ค. ์ต์ ํ์ค(ANSI SQL 2016)์ ์ฝ๋ ๋ฐ๋ ๋ง์ ์๊ฐ์ด ์์๋ ์ ์์ต๋๋ค. ์ด๋ป๊ฒ ๋ฐฐ์ธ ์ ์์๊น์?
-There are 5 components of the SQL language:
+SQL ์ธ์ด์๋ 5๊ฐ์ง ๊ตฌ์ฑ ์์๊ฐ ์์ต๋๋ค.
-- DDL: data definition language, such as CREATE, ALTER, DROP
-- DQL: data query language, such as SELECT
-- DML: data manipulation language, such as INSERT, UPDATE, DELETE
-- DCL: data control language, such as GRANT, REVOKE
-- TCL: transaction control language, such as COMMIT, ROLLBACK
+- DDL: data definition language. ์: CREATE, ALTER, DROP
+- DQL: data query language. ์: SELECT
+- DML: data manipulation language. ์: INSERT, UPDATE, DELETE
+- DCL: data control language. ์: GRANT, REVOKE
+- TCL: transaction control language. ์: COMMIT, ROLLBACK
-For a backend engineer, you may need to know most of it. As a data analyst, you may need to have a good understanding of DQL. Select the topics that are most relevant to you.
+๋ฐฑ์๋ ์์ง๋์ด์ ๊ฒฝ์ฐ ๋๋ถ๋ถ์ ์์์ผ ํ ์๋ ์์ต๋๋ค. ๋ฐ์ดํฐ ๋ถ์๊ฐ๋ผ๋ฉด DQL์ ์ ์ดํดํด์ผ ํ ์๋ ์์ต๋๋ค. ์์ ์๊ฒ ๊ฐ์ฅ ๊ด๋ จ์ฑ์ด ๋์ ์ฃผ์ ๋ฅผ ์ ํํ์ธ์.
## Cache
### Data is cached everywhere
-This diagram illustrates where we cache data in a typical architecture.
+์ด ๋ค์ด์ด๊ทธ๋จ์ ์ผ๋ฐ์ ์ธ ์ํคํ
์ฒ์์ ๋ฐ์ดํฐ๋ฅผ ์บ์ํ๋ ์์น๋ฅผ ๋ณด์ฌ์ค๋๋ค.
-There are **multiple layers** along the flow.
+ํ๋ก์ฐ๋ฅผ ๋ฐ๋ผ **multiple layers** ๊ฐ ์์ต๋๋ค.
-1. Client apps: HTTP responses can be cached by the browser. We request data over HTTP for the first time, and it is returned with an expiry policy in the HTTP header; we request data again, and the client app tries to retrieve the data from the browser cache first.
-2. CDN: CDN caches static web resources. The clients can retrieve data from a CDN node nearby.
-3. Load Balancer: The load Balancer can cache resources as well.
-4. Messaging infra: Message brokers store messages on disk first, and then consumers retrieve them at their own pace. Depending on the retention policy, the data is cached in Kafka clusters for a period of time.
-5. Services: There are multiple layers of cache in a service. If the data is not cached in the CPU cache, the service will try to retrieve the data from memory. Sometimes the service has a second-level cache to store data on disk.
-6. Distributed Cache: Distributed cache like Redis holds key-value pairs for multiple services in memory. It provides much better read/write performance than the database.
-7. Full-text Search: we sometimes need to use full-text searches like Elastic Search for document search or log search. A copy of data is indexed in the search engine as well.
-8. Database: Even in the database, we have different levels of caches:
-- WAL(Write-ahead Log): data is written to WAL first before building the B tree index
-- Bufferpool: A memory area allocated to cache query results
-- Materialized View: Pre-compute query results and store them in the database tables for better query performance
-- Transaction log: record all the transactions and database updates
-- Replication Log: used to record the replication state in a database cluster
+1. Client apps: HTTP ์๋ต์ ๋ธ๋ผ์ฐ์ ์ ์ํด ์บ์๋ ์ ์์ต๋๋ค. HTTP๋ฅผ ํตํด ์ฒ์์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ์์ฒญํ๋ฉด HTTP ํค๋์ ๋ง๋ฃ ์ ์ฑ
๊ณผ ํจ๊ป ๋ฐํ๋๋ฉฐ, ๋ฐ์ดํฐ๋ฅผ ๋ค์ ์์ฒญํ๋ฉด ํด๋ผ์ด์ธํธ ์ฑ์ด ๋จผ์ ๋ธ๋ผ์ฐ์ ์บ์์์ ๋ฐ์ดํฐ๋ฅผ ๊ฒ์ํ๋ ค๊ณ ์๋ํฉ๋๋ค.
+2. CDN: CDN์ ์ ์ ์น ๋ฆฌ์์ค๋ฅผ ์บ์ํฉ๋๋ค. ํด๋ผ์ด์ธํธ๋ ๊ทผ์ฒ์ CDN ๋
ธ๋์์ ๋ฐ์ดํฐ๋ฅผ ๊ฒ์ํ ์ ์์ต๋๋ค.
+3. Load Balancer: ๋ก๋ ๋ฐธ๋ฐ์๋ ๋ฆฌ์์ค๋ ์บ์ํ ์ ์์ต๋๋ค.
+4. Messaging infra: Message brokers๊ฐ ๋จผ์ ๋์คํฌ์ ๋ฉ์์ง๋ฅผ ์ ์ฅํ ๋ค์, consumers๋ ์์ ์ ์๋์ ๋ง์ถฐ ๋ฉ์์ง๋ฅผ ๊ฒ์ํฉ๋๋ค. ๋ฆฌํ
์
ํด๋ฆฌ์์ ๋ฐ๋ผ ๋ฐ์ดํฐ๋ ์ผ์ ๊ธฐ๊ฐ ๋์ ์นดํ์นด ํด๋ฌ์คํฐ์ ์บ์๋ฉ๋๋ค.
+5. Services: ์๋น์ค์๋ ์ฌ๋ฌ๊ฐ์ ์บ์ ๊ณ์ธต์ด ์์ต๋๋ค. CPU ์บ์์ ๋ฐ์ดํฐ๊ฐ ์์ผ๋ฉด ๋ฉ๋ชจ๋ฆฌ ์บ์์์ ๊ฒ์์ ์๋ํฉ๋๋ค. ๋๋ก๋ ์๋น์ค๊ฐ ๋์คํฌ์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ ์ธ์ปจ๋ ๋ ๋ฒจ ์บ์๊ฐ ์๋ ๊ฒฝ์ฐ๋ ์์ต๋๋ค.
+6. Distributed Cache: Redis์ ๊ฐ์ ๋ถ์ฐ ์บ์๋ ์ฌ๋ฌ ์๋น์ค์ ๋ํ ํค-๊ฐ ์์ ๋ฉ๋ชจ๋ฆฌ์ ๋ณด๊ดํฉ๋๋ค. ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ณด๋ค ํจ์ฌ ๋ฐ์ด๋ ์ฝ๊ธฐ/์ฐ๊ธฐ ์ฑ๋ฅ์ ์ ๊ณตํฉ๋๋ค.
+7. Full-text Search: ๋ํ๋จผํธ ๊ฒ์์ด๋ ๋ก๊ทธ ๊ฒ์์ ์ํด Elastic Search์ ๊ฐ์ ํ ํ
์คํธ ๊ฒ์์ ์ฌ์ฉํด์ผ ํ ๋๊ฐ ์์ต๋๋ค. ๋ฐ์ดํฐ ์ฌ๋ณธ๋ ๊ฒ์ ์์ง์์ ์ธ๋ฑ์ค๋ฉ๋๋ค.
+8. Database: ๋ฐ์ดํฐ๋ฒ ์ด์ค ๋ด์์๋ ๋ค์ํ ๋ ๋ฒจ์ ์บ์๊ฐ ์์ต๋๋ค.
+- WAL(Write-ahead Log): ๋ฐ์ดํฐ๋ B ํธ๋ฆฌ ์ธ๋ฑ์ค๋ฅผ ๊ตฌ์ถํ๊ธฐ ์ ์ ๋จผ์ WAL์ ๊ธฐ๋ก๋ฉ๋๋ค.
+- Bufferpool: ์ฟผ๋ฆฌ ๊ฒฐ๊ณผ๋ฅผ ์บ์ํ๊ธฐ ์ํด ํ ๋น๋ ๋ฉ๋ชจ๋ฆฌ ์์ญ์
๋๋ค.
+- Materialized View: ์ฟผ๋ฆฌ ๊ฒฐ๊ณผ๋ฅผ ๋ฏธ๋ฆฌ ๊ณ์ฐํ๊ณ ๋ฐ์ดํฐ๋ฒ ์ด์ค ํ
์ด๋ธ์ ์ ์ฅํ์ฌ ์ฟผ๋ฆฌ ์ฑ๋ฅ์ ํฅ์์ํต๋๋ค.
+- Transaction log: ๋ชจ๋ ํธ๋์ญ์
๊ณผ ๋ฐ์ดํฐ๋ฒ ์ด์ค ์
๋ฐ์ดํธ ๊ธฐ๋กํฉ๋๋ค.
+- Replication Log: ๋ฐ์ดํฐ๋ฒ ์ด์ค ํด๋ฌ์คํฐ์ ๋ณต์ ์ํ๋ฅผ ๊ธฐ๋กํ๋ ๋ฐ ์ฌ์ฉ๋ฉ๋๋ค.
### Why is Redis so fast?
-There are 3 main reasons as shown in the diagram below.
+์๋ ๋ค์ด์ด๊ทธ๋จ๊ณผ ๊ฐ์ด 3๊ฐ์ง ์ฃผ์ ์ด์ ๊ฐ ์์ต๋๋ค.
From 4f4af4c75235ead28e3cf83c7266856651e16845 Mon Sep 17 00:00:00 2001
From: Deadintegral
Date: Sun, 28 Jan 2024 23:27:22 +0900
Subject: [PATCH 06/16] docs: translate content table
---
translations/README-kr.md | 176 +++++++++++++++++++-------------------
1 file changed, 88 insertions(+), 88 deletions(-)
diff --git a/translations/README-kr.md b/translations/README-kr.md
index 815d6b0..80ed9d3 100644
--- a/translations/README-kr.md
+++ b/translations/README-kr.md
@@ -26,9 +26,9 @@
- [Communication protocols](#communication-protocols)
- [REST API vs. GraphQL](#rest-api-vs-graphql)
- - [gRPC๋ ์ด๋ป๊ฒ ์๋ํ๋์?](#how-does-grpc-work)
+ - [gRPC๋ ์ด๋ป๊ฒ ์๋ํ๋์?](#grpc๋-์ด๋ป๊ฒ-์๋ํ๋์)
- [webhook์ด๋ ๋ฌด์์ธ๊ฐ์?](#what-is-a-webhook)
- - [API ์ฑ๋ฅ์ ๊ฐ์ ํ๋ ๋ฐฉ๋ฒ์ ๋ฌด์์ธ๊ฐ์?](#how-to-improve-api-performance)
+ - [API ์ฑ๋ฅ์ ๊ฐ์ ํ๋ ๋ฐฉ๋ฒ์ ๋ฌด์์ธ๊ฐ์?](#api-์ฑ๋ฅ์-๊ฐ์ ํ๋-๋ฐฉ๋ฒ์-๋ฌด์์ธ๊ฐ์)
- [HTTP 1.0 -\> HTTP 1.1 -\> HTTP 2.0 -\> HTTP 3.0 (QUIC)](#http-10---http-11---http-20---http-30-quic)
- [SOAP vs REST vs GraphQL vs RPC](#soap-vs-rest-vs-graphql-vs-rpc)
- [Code First vs. API First](#code-first-vs-api-first)
@@ -36,74 +36,74 @@
- [API gateway๋ ๋ฌด์์ ํ๋์?](#what-does-api-gateway-do)
- [ํจ๊ณผ์ ์ด๊ณ ์์ ํ API๋ฅผ ์ค๊ณํ๋ ค๋ฉด ์ด๋ป๊ฒ ํด์ผ ํ ๊น์?](#how-do-we-design-effective-and-safe-apis)
- [TCP/IP encapsulation](#tcpip-encapsulation)
- - [์ Nginx๋ฅผ "reverse" ํ๋ก์๋ผ๊ณ ๋ถ๋ฅด๋์?](#why-is-nginx-called-a-reverse-proxy)
- - [์ผ๋ฐ์ ์ธ ๋ก๋ ๋ฐธ๋ฐ์ฑ ์๊ณ ๋ฆฌ์ฆ์ ๋ฌด์์ธ๊ฐ์?](#what-are-the-common-load-balancing-algorithms)
- - [URL, URI, URN - ์ฐจ์ด๋ฅผ ์๊ณ ์๋์?](#url-uri-urn---do-you-know-the-differences)
+ - [์ Nginx๋ฅผ "reverse" ํ๋ก์๋ผ๊ณ ๋ถ๋ฅด๋์?](#์-nginx๋ฅผ-reverse-ํ๋ก์๋ผ๊ณ -๋ถ๋ฅด๋์)
+ - [์ผ๋ฐ์ ์ธ ๋ก๋ ๋ฐธ๋ฐ์ฑ ์๊ณ ๋ฆฌ์ฆ์ ๋ฌด์์ธ๊ฐ์?](#์ผ๋ฐ์ ์ธ-๋ก๋-๋ฐธ๋ฐ์ฑ-์๊ณ ๋ฆฌ์ฆ์-๋ฌด์์ธ๊ฐ์)
+ - [URL, URI, URN - ์ฐจ์ด๋ฅผ ์๊ณ ์๋์?](#url-uri-urn---์ฐจ์ด๋ฅผ-์๊ณ -์๋์)
- [CI/CD](#cicd)
- - [์ฌ์ด ์ฉ์ด๋ก ์ค๋ช
ํ๋ CI/CD ํ์ดํ๋ผ์ธ](#cicd-pipeline-explained-in-simple-terms)
- - [๋ทํ๋ฆญ์ค ํ
ํฌ ์คํ (CI/CD Pipeline)](#netflix-tech-stack-cicd-pipeline)
-- [์ํคํ
์ฒ ํจํด](#architecture-patterns)
- - [MVC, MVP, MVVM, MVVM-C, and VIPER](#mvc-mvp-mvvm-mvvm-c-and-viper)
+ - [์ฌ์ด ์ฉ์ด๋ก ์ค๋ช
ํ๋ CI/CD ํ์ดํ๋ผ์ธ](#์ฌ์ด-์ฉ์ด๋ก-์ค๋ช
ํ๋-cicd-ํ์ดํ๋ผ์ธ)
+ - [๋ทํ๋ฆญ์ค ๊ธฐ์ ์คํ (CI/CD Pipeline)](#๋ทํ๋ฆญ์ค-๊ธฐ์ ์คํ-cicd-pipeline)
+- [์ํคํ
์ฒ ํจํด](#์ํคํ
์ฒ-ํจํด)
+ - [MVC, MVP, MVVM, MVVM-C, VIPER](#mvc-mvp-mvvm-mvvm-c-and-viper)
- [18 Key Design Patterns Every Developer Should Know](#18-key-design-patterns-every-developer-should-know)
- [Database](#database)
- - [A nice cheat sheet of different databases in cloud services](#a-nice-cheat-sheet-of-different-databases-in-cloud-services)
- - [8 Data Structures That Power Your Databases](#8-data-structures-that-power-your-databases)
- - [How is an SQL statement executed in the database?](#how-is-an-sql-statement-executed-in-the-database)
- - [CAP theorem](#cap-theorem)
- - [Types of Memory and Storage](#types-of-memory-and-storage)
- - [Visualizing a SQL query](#visualizing-a-sql-query)
- - [SQL language](#sql-language)
-- [Cache](#cache)
- - [Data is cached everywhere](#data-is-cached-everywhere)
- - [Why is Redis so fast?](#why-is-redis-so-fast)
- - [How can Redis be used?](#how-can-redis-be-used)
- - [Top caching strategies](#top-caching-strategies)
-- [Microservice architecture](#microservice-architecture)
- - [What does a typical microservice architecture look like?](#what-does-a-typical-microservice-architecture-look-like)
- - [Microservice Best Practices](#microservice-best-practices)
- - [What tech stack is commonly used for microservices?](#what-tech-stack-is-commonly-used-for-microservices)
- - [Why is Kafka fast](#why-is-kafka-fast)
-- [Payment systems](#payment-systems)
- - [How to learn payment systems?](#how-to-learn-payment-systems)
- - [Why is the credit card called โthe most profitable product in banksโ? How does VISA/Mastercard make money?](#why-is-the-credit-card-called-the-most-profitable-product-in-banks-how-does-visamastercard-make-money)
+ - [ํด๋ผ์ฐ๋ ์๋น์ค์ ๋ค์ํ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ๊ดํ ์นํธ์ํธ](#ํด๋ผ์ฐ๋-์๋น์ค์-๋ค์ํ-๋ฐ์ดํฐ๋ฒ ์ด์ค์-๊ดํ-์นํธ์ํธ)
+ - [๋ฐ์ดํฐ๋ฒ ์ด์ค๋ฅผ ๊ฐํํ๋ 8๊ฐ์ง ๋ฐ์ดํฐ ๊ตฌ์กฐ](#๋ฐ์ดํฐ๋ฒ ์ด์ค๋ฅผ-๊ฐํํ๋-8๊ฐ์ง-๋ฐ์ดํฐ-๊ตฌ์กฐ)
+ - [๋ฐ์ดํฐ๋ฒ ์ด์ค์์ SQL ๋ฌธ์ ์ด๋ป๊ฒ ์คํ๋๋์?](#๋ฐ์ดํฐ๋ฒ ์ด์ค์์-SQL-๋ฌธ์-์ด๋ป๊ฒ-์คํ๋๋์)
+ - [CAP ์ ๋ฆฌ](#cap-์ ๋ฆฌ)
+ - [๋ฉ๋ชจ๋ฆฌ ๋ฐ ์คํ ๋ฆฌ์ง์ ์ข
๋ฅ](#๋ฉ๋ชจ๋ฆฌ-๋ฐ-์คํ ๋ฆฌ์ง์-์ข
๋ฅ)
+ - [SQL ์ฟผ๋ฆฌ ์๊ฐํ](#SQL-์ฟผ๋ฆฌ-์๊ฐํ)
+ - [SQL ์ธ์ด](#sql-์ธ์ด)
+- [์บ์](#์บ์)
+ - [๋ฐ์ดํฐ๋ ์ด๋์๋ ์บ์๋ฉ๋๋ค](#๋ฐ์ดํฐ๋-์ด๋์๋-์บ์๋ฉ๋๋ค)
+ - [Redis๋ ์ ๋น ๋ฅธ๊ฐ์?](#redis๋-์-๋น ๋ฅธ๊ฐ์)
+ - [Redis๋ ์ด๋ป๊ฒ ์ฌ์ฉํ๋์?](#redis๋-์ด๋ป๊ฒ-์ฌ์ฉํ๋์)
+ - [์ฃผ์ ์บ์ฑ ์ ๋ต](#์ฃผ์-์บ์ฑ-์ ๋ต)
+- [๋ง์ดํฌ๋ก์๋น์ค ์ํคํ
์ฒ](#๋ง์ดํฌ๋ก์๋น์ค-์ํคํ
์ฒ)
+ - [์ผ๋ฐ์ ์ธ ๋ง์ดํฌ๋ก์๋น์ค ์ํคํ
์ฒ๋ ์ด๋ค ๋ชจ์ต์ผ๊น์?](#์ผ๋ฐ์ ์ธ-๋ง์ดํฌ๋ก์๋น์ค-์ํคํ
์ฒ๋-์ด๋ค-๋ชจ์ต์ผ๊น์)
+ - [๋ง์ดํฌ๋ก์๋น์ค ๋ชจ๋ฒ ์ฌ๋ก](#๋ง์ดํฌ๋ก์๋น์ค-๋ชจ๋ฒ์ฌ๋ก)
+ - [๋ง์ดํฌ๋ก์๋น์ค์ ์ผ๋ฐ์ ์ผ๋ก ์ฌ์ฉํ๋ ๊ธฐ์ ์คํ์ ๋ฌด์์ธ๊ฐ์?](#๋ง์ดํฌ๋ก์๋น์ค์-์ผ๋ฐ์ ์ผ๋ก-์ฌ์ฉํ๋-๊ธฐ์ -์คํ์-๋ฌด์์ธ๊ฐ์)
+ - [์นดํ์นด๊ฐ ๋น ๋ฅธ ์ด์ ](#์นดํ์นด๊ฐ-๋น ๋ฅธ-์ด์ )
+- [๊ฒฐ์ ์์คํ
](#๊ฒฐ์ -์์คํ
)
+ - [๊ฒฐ์ ์์คํ
์ ๋ฐฐ์ฐ๋ ๋ฐฉ๋ฒ์ ๋ฌด์์ธ๊ฐ์?](#how-to-learn-payment-systems)
+ - [์ ์ฉ์นด๋๋ฅผ "์ํ์์ ๊ฐ์ฅ ์์ต์ฑ์ด ๋์ ์ํ"์ด๋ผ๊ณ ๋ถ๋ฅด๋ ์ด์ ๋ ๋ฌด์์ธ๊ฐ์? ๋น์/๋ง์คํฐ์นด๋๋ ์ด๋ป๊ฒ ์์ต์ ์ฐฝ์ถํ๋์?](#why-is-the-credit-card-called-the-most-profitable-product-in-banks-how-does-visamastercard-make-money)
- [How does VISA work when we swipe a credit card at a merchantโs shop?](#how-does-visa-work-when-we-swipe-a-credit-card-at-a-merchants-shop)
- - [Payment Systems Around The World Series (Part 1): Unified Payments Interface (UPI) in India](#payment-systems-around-the-world-series-part-1-unified-payments-interface-upi-in-india)
+ - [์ธ๊ณ์ ๊ฒฐ์ ์์คํ
์๋ฆฌ์ฆ(1๋ถ): ์ธ๋์ ํตํฉ ๊ฒฐ์ ์ธํฐํ์ด์ค(UPI)](#payment-systems-around-the-world-series-part-1-unified-payments-interface-upi-in-india)
- [DevOps](#devops)
- - [DevOps vs. SRE vs. Platform Engineering. What is the difference?](#devops-vs-sre-vs-platform-engineering-what-is-the-difference)
- - [What is k8s (Kubernetes)?](#what-is-k8s-kubernetes)
- - [Docker vs. Kubernetes. Which one should we use?](#docker-vs-kubernetes-which-one-should-we-use)
- - [How does Docker work?](#how-does-docker-work)
+ - [DevOps vs. SRE vs. Platform Engineering. ๋ฌด์์ด ๋ค๋ฅธ๊ฐ์?](#devops-vs-sre-vs-platform-engineering-what-is-the-difference)
+ - [k8s(Kubernetes)๋ ๋ฌด์์ธ๊ฐ์?](#what-is-k8s-kubernetes)
+ - [Docker vs. Kubernetes. ์ด๋ค๊ฒ์ ์ฌ์ฉํด์ผ ํ๋์?](#docker-vs-kubernetes-which-one-should-we-use)
+ - [Docker๋ ์ด๋ป๊ฒ ์๋ํ๋์?](#how-does-docker-work)
- [GIT](#git)
- - [How Git Commands work](#how-git-commands-work)
- - [How does Git Work?](#how-does-git-work)
+ - [Git Commands ์๋ ๋ฐฉ์](#how-git-commands-work)
+ - [Git์ ์ด๋ป๊ฒ ์๋ํ๋์?](#how-does-git-work)
- [Git merge vs. Git rebase](#git-merge-vs-git-rebase)
-- [Cloud Services](#cloud-services)
- - [A nice cheat sheet of different cloud services (2023 edition)](#a-nice-cheat-sheet-of-different-cloud-services-2023-edition)
- - [What is cloud native?](#what-is-cloud-native)
+- [ํด๋ผ์ฐ๋ ์๋น์ค](#cloud-services)
+ - [๋ค์ํ ํด๋ผ์ฐ๋ ์๋น์ค์ ๋ํ ์ ์ฉํ ์นํธ์ํธ(2023๋
ํ)](#a-nice-cheat-sheet-of-different-cloud-services-2023-edition)
+ - [cloud native๋ ๋ฌด์์ธ๊ฐ์?](#what-is-cloud-native)
- [Developer productivity tools](#developer-productivity-tools)
- - [Visualize JSON files](#visualize-json-files)
- - [Automatically turn code into architecture diagrams](#automatically-turn-code-into-architecture-diagrams)
-- [Linux](#linux)
- - [Linux file system explained](#linux-file-system-explained)
- - [18 Most-used Linux Commands You Should Know](#18-most-used-linux-commands-you-should-know)
-- [Security](#security)
- - [How does HTTPS work?](#how-does-https-work)
- - [Oauth 2.0 Explained With Simple Terms.](#oauth-20-explained-with-simple-terms)
- - [Top 4 Forms of Authentication Mechanisms](#top-4-forms-of-authentication-mechanisms)
- - [Session, cookie, JWT, token, SSO, and OAuth 2.0 - what are they?](#session-cookie-jwt-token-sso-and-oauth-20---what-are-they)
- - [How to store passwords safely in the database and how to validate a password?](#how-to-store-passwords-safely-in-the-database-and-how-to-validate-a-password)
- - [Explaining JSON Web Token (JWT) to a 10 year old Kid](#explaining-json-web-token-jwt-to-a-10-year-old-kid)
- - [How does Google Authenticator (or other types of 2-factor authenticators) work?](#how-does-google-authenticator-or-other-types-of-2-factor-authenticators-work)
-- [Real World Case Studies](#real-world-case-studies)
- - [Netflix's Tech Stack](#netflixs-tech-stack)
- - [Twitter Architecture 2022](#twitter-architecture-2022)
- - [Evolution of Airbnbโs microservice architecture over the past 15 years](#evolution-of-airbnbs-microservice-architecture-over-the-past-15-years)
- - [Monorepo vs. Microrepo.](#monorepo-vs-microrepo)
- - [How will you design the Stack Overflow website?](#how-will-you-design-the-stack-overflow-website)
- - [Why did Amazon Prime Video monitoring move from serverless to monolithic? How can it save 90% cost?](#why-did-amazon-prime-video-monitoring-move-from-serverless-to-monolithic-how-can-it-save-90-cost)
- - [How does Disney Hotstar capture 5 Billion Emojis during a tournament?](#how-does-disney-hotstar-capture-5-billion-emojis-during-a-tournament)
- - [How Discord Stores Trillions Of Messages](#how-discord-stores-trillions-of-messages)
- - [How do video live streamings work on YouTube, TikTok live, or Twitch?](#how-do-video-live-streamings-work-on-youtube-tiktok-live-or-twitch)
+ - [JSON ํ์ผ ์๊ฐํ](#visualize-json-files)
+ - [์ฝ๋๋ฅผ ์ํคํ
์ฒ ๋ค์ด์ด๊ทธ๋จ์ผ๋ก ์๋ ๋ณํ](#automatically-turn-code-into-architecture-diagrams)
+- [๋ฆฌ๋
์ค](#linux)
+ - [๋ฆฌ๋
์ค ํ์ผ ์์คํ
์ค๋ช
](#linux-file-system-explained)
+ - [๊ฐ์ฅ ๋ง์ด ์ฌ์ฉ๋๋ 18๊ฐ์ง ๋ฆฌ๋
์ค ๋ช
๋ น์ด ์์๋ณด๊ธฐ](#18-most-used-linux-commands-you-should-know)
+- [๋ณด์](#security)
+ - [HTTPS๋ ์ด๋ป๊ฒ ์๋ํ๋์?](#how-does-https-work)
+ - [๊ฐ๋จํ ์ฉ์ด๋ก ์ค๋ช
ํ๋ Oauth 2.0](#oauth-20-explained-with-simple-terms)
+ - [์ธ์ฆ ๋ฉ์ปค๋์ฆ์ 4๊ฐ์ง ์ฃผ์ ํํ](#top-4-forms-of-authentication-mechanisms)
+ - [Session, cookie, JWT, token, SSO, OAuth 2.0 - ๊ทธ๊ฒ ๋ญ๊ฐ์?](#session-cookie-jwt-token-sso-and-oauth-20---what-are-they)
+ - [๋ฐ์ดํฐ๋ฒ ์ด์ค์ ๋น๋ฐ๋ฒํธ๋ฅผ ์์ ํ๊ฒ ์ ์ฅํ๋ ๋ฐฉ๋ฒ๊ณผ ๋น๋ฐ๋ฒํธ๋ฅผ ํ์ธํ๋ ๋ฐฉ๋ฒ์ ๋ฌด์์ธ๊ฐ์?](#how-to-store-passwords-safely-in-the-database-and-how-to-validate-a-password)
+ - [10์ธ ์ด๋ฆฐ์ด์๊ฒ JSON Web Token(JWT) ์ค๋ช
ํ๊ธฐ](#explaining-json-web-token-jwt-to-a-10-year-old-kid)
+ - [Google authenticator(๋๋ ๋ค๋ฅธ ์ ํ์ 2 factor authenticator)๋ ์ด๋ป๊ฒ ์๋ํ๋์?](#how-does-google-authenticator-or-other-types-of-2-factor-authenticators-work)
+- [์ค์ ์ฌ๋ก ์ฐ๊ตฌ](#real-world-case-studies)
+ - [๋ทํ๋ฆญ์ค ๊ธฐ์ ์คํ](#netflixs-tech-stack)
+ - [ํธ์ํฐ ์ํคํ
์ฒ 2022](#twitter-architecture-2022)
+ - [์ง๋ 15๋
๊ฐ ์์ด๋น์ค๋น ๋ง์ดํฌ๋ก์๋น์ค ์ํคํ
์ฒ์ ์งํ ๊ณผ์ ](#evolution-of-airbnbs-microservice-architecture-over-the-past-15-years)
+ - [๋ชจ๋
ธ๋ ํฌ vs. ๋ง์ดํฌ๋ก๋ ํฌ](#monorepo-vs-microrepo)
+ - [์คํ ์ค๋ฒํ๋ก ์น์ฌ์ดํธ๋ฅผ ์ด๋ป๊ฒ ๋์์ธํ ๊ฑด๊ฐ์?](#how-will-you-design-the-stack-overflow-website)
+ - [์๋ง์กด ํ๋ผ์ ๋น๋์ค ๋ชจ๋ํฐ๋ง์ด ์๋ฒ๋ฆฌ์ค์์ ๋ชจ๋๋ฆฌ์์ผ๋ก ์ ํ๋ ์ด์ ๋ ๋ฌด์์ธ๊ฐ์? ์ด๋ป๊ฒ 90%์ ๋น์ฉ์ ์ ๊ฐํ ์ ์์๊น์?](#why-did-amazon-prime-video-monitoring-move-from-serverless-to-monolithic-how-can-it-save-90-cost)
+ - [๋์ฆ๋ ํซ์คํ๋ ์ด๋ป๊ฒ ํ ๋๋จผํธ ๊ธฐ๊ฐ ๋์ 50์ต ๊ฐ์ ์ด๋ชจํฐ์ฝ์ ํ๋ํ ์ ์์๋์?](#how-does-disney-hotstar-capture-5-billion-emojis-during-a-tournament)
+ - [Discord๊ฐ ์์กฐ ๊ฐ์ ๋ฉ์์ง๋ฅผ ์ ์ฅํ๋ ๋ฐฉ๋ฒ](#how-discord-stores-trillions-of-messages)
+ - [๋์์ ๋ผ์ด๋ธ ์คํธ๋ฆฌ๋ฐ์ YouTube, TikTok ๋ผ์ด๋ธ, Twitch์์ ์ด๋ป๊ฒ ์๋ํ๋์?](#how-do-video-live-streamings-work-on-youtube-tiktok-live-or-twitch)
@@ -183,7 +183,7 @@ GraphQL
๋ API ๋ฐฉ์ ๋ชจ๋ ์์ด์์ ์๋๋๋ค. ์ฌ๋ฐ๋ฅธ ์คํ์ผ์ ์ ํํ๋ ค๋ฉด ์๊ตฌ ์ฌํญ๊ณผ ์ฅ๋จ์ ์ ์ ์คํ๊ฒ ํ๊ฐํ๋ ๊ฒ์ด ์ค์ํฉ๋๋ค. REST์ GraphQL์ ๋ชจ๋ ๋ฐ์ดํฐ๋ฅผ ๋
ธ์ถํ๊ณ ์ต์ ์ ํ๋ฆฌ์ผ์ด์
์ ๊ตฌ๋ํ๋ ๋ฐ ์ ํจํ ์ต์
์
๋๋ค.
-### How does gRPC work?
+### gRPC๋ ์ด๋ป๊ฒ ์๋ํ๋์?
RPC(Remote Procedure Call)๋ ๋ง์ดํฌ๋ก์๋น์ค ์ํคํ
์ฒ์์ ์๋น์ค๊ฐ ์๋ก ๋ค๋ฅธ ์๋ฒ์ ๋ฐฐํฌ๋ ๋ ์๊ฒฉ ์๋น์ค ๊ฐ์ ํต์ ์ ๊ฐ๋ฅํ๊ฒ ํ๊ธฐ ๋๋ฌธ์ "**remote**"๋ผ๊ณ ๋ถ๋ฆฝ๋๋ค. ์ฌ์ฉ์ ์
์ฅ์์๋ ๋ก์ปฌ ํจ์ ํธ์ถ์ฒ๋ผ ์๋ํฉ๋๋ค.
@@ -239,7 +239,7 @@ PSP๊ฐ ๋ค์ ์๋ตํ์ง ์์ผ๋ฉด ์ด๋ป๊ฒ ํ๋์? ๋งค์๊ฐ ๊ฒฐ์ ์
2. ๋ณด์์ ์ํด API ๊ฒ์ดํธ์จ์ด์ ์ ์ ํ ๊ท์น์ ์ค์ ํด์ผ ํฉ๋๋ค.
3. ์ธ๋ถ ์๋น์ค์ ์ฌ๋ฐ๋ฅธ URL์ ๋ฑ๋กํด์ผ ํฉ๋๋ค.
-### How to improve API performance?
+### API ์ฑ๋ฅ์ ๊ฐ์ ํ๋ ๋ฐฉ๋ฒ์ ๋ฌด์์ธ๊ฐ์?
์๋ ๋ค์ด์ด๊ทธ๋จ์ API ์ฑ๋ฅ์ ๊ฐ์ ํ๋ 5๊ฐ์ง ์ผ๋ฐ์ ์ธ ๋ฐฉ๋ฒ์ ๋ณด์ฌ์ค๋๋ค.
@@ -403,7 +403,7 @@ API ์ค๊ณ๋ ๋จ์ํ URL path ์ค๊ณ๊ฐ ์๋๋ผ๋ ์ ์ ์ ์ํ์ธ์.
๋คํธ์ํฌ ๋ชจ๋ธ์ ๊ณ์ธต์ด ํ์ํ ์ด์ ๋ ๊ฐ ๊ณ์ธต์ด ๊ณ ์ ํ ์ฑ
์์ ์ง์คํ๊ธฐ ๋๋ฌธ์
๋๋ค. ๊ฐ ๊ณ์ธต์ ์ฒ๋ฆฌ ์ง์นจ์ ํค๋์ ์์กดํ ์ ์์ผ๋ฉฐ ๋ง์ง๋ง ๊ณ์ธต์ ๋ฐ์ดํฐ์ ์๋ฏธ๋ฅผ ์ ํ์๊ฐ ์์ต๋๋ค.
-### Why is Nginx called a โreverseโ proxy?
+### ์ Nginx๋ฅผ "reverse" ํ๋ก์๋ผ๊ณ ๋ถ๋ฅด๋์?
์๋ ๋ค์ด์ด๊ทธ๋จ์ ๐๐จ๐ซ๐ฐ๐๐ซ๐ ๐ฉ๐ซ๐จ๐ฑ๐ฒ ์ ๐ซ๐๐ฏ๐๐ซ๐ฌ๐ ๐ฉ๐ซ๐จ๐ฑ๐ฒ ์ ์ฐจ์ด์ ์ ๋ณด์ฌ์ค๋๋ค.
@@ -428,7 +428,7 @@ API ์ค๊ณ๋ ๋จ์ํ URL path ์ค๊ณ๊ฐ ์๋๋ผ๋ ์ ์ ์ ์ํ์ธ์.
3. ์ ์ ์ฝํ
์ธ ์บ์ฑ
4. SSL ํต์ ์ํธํ ๋ฐ ๋ณตํธํ
-### What are the common load-balancing algorithms?
+### ์ผ๋ฐ์ ์ธ ๋ก๋ ๋ฐธ๋ฐ์ฑ ์๊ณ ๋ฆฌ์ฆ์ ๋ฌด์์ธ๊ฐ์?
์๋ ๋ค์ด์ด๊ทธ๋จ์ 6๊ฐ์ง ์ผ๋ฐ์ ์ธ ์๊ณ ๋ฆฌ์ฆ์ ๋ณด์ฌ์ค๋๋ค.
@@ -464,7 +464,7 @@ API ์ค๊ณ๋ ๋จ์ํ URL path ์ค๊ณ๊ฐ ์๋๋ผ๋ ์ ์ ์ ์ํ์ธ์.
์ ์์ฒญ์ ์๋ต ์๊ฐ์ด ๊ฐ์ฅ ๋น ๋ฅธ ์๋น์ค ์ธ์คํด์ค๋ก ์ ์ก๋ฉ๋๋ค.
-### URL, URI, URN - Do you know the differences?
+### URL, URI, URN - ์ฐจ์ด๋ฅผ-์๊ณ -์๋์?
์๋ ๋ค์ด์ด๊ทธ๋จ์ URL, URI, URN์ ๋น๊ต๋ฅผ ๋ณด์ฌ์ค๋๋ค.
@@ -491,7 +491,7 @@ URN์ Uniform Resource Name์ ์ฝ์๋ก, urn ์คํค๋ง๋ฅผ ์ฌ์ฉํฉ๋๋ค. URN
## CI/CD
-### CI/CD Pipeline Explained in Simple Terms
+### ์ฌ์ด ์ฉ์ด๋ก ์ค๋ช
ํ๋ CI/CD ํ์ดํ๋ผ์ธ
@@ -520,7 +520,7 @@ Continuous Delivery(CD)๋ ์ธํ๋ผ ๋ณ๊ฒฝ, ๋ฐฐํฌ์ ๊ฐ์ ๋ฆด๋ฆฌ์ค ํ๋ก
- ๋ฆด๋ฆฌ์ค ์ ์ ์คํ
์ด์ง ํ๊ฒฝ์์ ์ถ๊ฐ ํ
์คํธ๋ฅผ ์ํํ ์ ์์ต๋๋ค.
- CD ์์คํ
์ด ์น์ธํ ๋ณ๊ฒฝ ์ฌํญ์ ํ๋ก๋์
์ ๋ฐฐํฌํฉ๋๋ค.
-### Netflix Tech Stack (CI/CD Pipeline)
+### ๋ทํ๋ฆญ์ค ๊ธฐ์ ์คํ (CI/CD Pipeline)
@@ -542,7 +542,7 @@ Continuous Delivery(CD)๋ ์ธํ๋ผ ๋ณ๊ฒฝ, ๋ฐฐํฌ์ ๊ฐ์ ๋ฆด๋ฆฌ์ค ํ๋ก
์ธ์๋ํธ ๋ฆฌํฌํธ: ์ฐ์ ์์์ ๋ฐ๋ผ ์ธ์๋ํธ๊ฐ ๋ฐ์ก๋๋ฉฐ, ์ฌ๊ณ ์ฒ๋ฆฌ๋ฅผ ์ํด PagerDuty๊ฐ ์ฌ์ฉ๋ฉ๋๋ค.
-## Architecture patterns
+## ์ํคํ
์ฒ ํจํด
### MVC, MVP, MVVM, MVVM-C, VIPER
์ด๋ฌํ ์ํคํ
์ฒ ํจํด์ iOS, Android ํ๋ซํผ์์ ์ฑ ๊ฐ๋ฐ ์ ๊ฐ์ฅ ์ผ๋ฐ์ ์ผ๋ก ์ฌ์ฉํ๋ ํจํด์
๋๋ค. ๊ฐ๋ฐ์๋ค์ ์ด์ ํจํด์ ํ๊ณ๋ฅผ ๊ทน๋ณตํ๊ธฐ ์ํด ์ด๋ฌํ ํจํด์ ๋์
ํ์ต๋๋ค. ๊ทธ๋ ๋ค๋ฉด ์ด๋ป๊ฒ ๋ค๋ฅผ๊น์?
@@ -585,7 +585,7 @@ Continuous Delivery(CD)๋ ์ธํ๋ผ ๋ณ๊ฒฝ, ๋ฐฐํฌ์ ๊ฐ์ ๋ฆด๋ฆฌ์ค ํ๋ก
## Database
-### A nice cheat sheet of different databases in cloud services
+### ํด๋ผ์ฐ๋ ์๋น์ค์ ๋ค์ํ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ๊ดํ ์นํธ์ํธ
@@ -597,7 +597,7 @@ Continuous Delivery(CD)๋ ์ธํ๋ผ ๋ณ๊ฒฝ, ๋ฐฐํฌ์ ๊ฐ์ ๋ฆด๋ฆฌ์ค ํ๋ก
์ฐธ๊ณ : Google์ ๋ฐ์ดํฐ๋ฒ ์ด์ค ์ ์ฆ์ผ์ด์ค์ ๋ํ ๋ฌธ์๊ฐ ์ ํ๋์ด ์์ต๋๋ค. ์ฌ์ฉ ๊ฐ๋ฅํ ์๋ฃ๋ฅผ ์ต๋ํ ๊ฒํ ํ๊ณ ์ต์ ์ ์ต์
์ ์ ์ํ์ง๋ง, ์ผ๋ถ ํญ๋ชฉ์ ๋ ์ ํํ ์ ๋ณด๊ฐ ํ์ํ ์ ์์ต๋๋ค.
-### 8 Data Structures That Power Your Databases
+### ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ฅผ ๊ฐํํ๋ 8๊ฐ์ง ๋ฐ์ดํฐ ๊ตฌ์กฐ
์ ๋ต์ ์ ์ฆ์ผ์ด์ค์ ๋ฐ๋ผ ๋ฌ๋ผ์ง๋๋ค. ๋ฐ์ดํฐ๋ ๋ฉ๋ชจ๋ฆฌ๋ ๋์คํฌ์ ์ธ๋ฑ์ค๋ ์ ์์ต๋๋ค. ๋ง์ฐฌ๊ฐ์ง๋ก ๋ฐ์ดํฐ ํฌ๋งท๋ ๋๋ฒ, ์คํธ๋ง, ์ง๋ฆฌ์ ์ขํ ๋ฑ ๋ค์ํฉ๋๋ค. ์์คํ
์ด ์ฐ๊ธฐ ์ค์ฌ์ผ ์๋ ์๊ณ ์ฝ๊ธฐ ์ค์ฌ์ผ ์๋ ์์ต๋๋ค. ์ด๋ฌํ ๋ชจ๋ ์์๋ ๋ฐ์ดํฐ๋ฒ ์ด์ค ์ธ๋ฑ์ค ํฌ๋งท ์ ํ์ ์ํฅ์ ๋ฏธ์นฉ๋๋ค.
@@ -616,7 +616,7 @@ Continuous Delivery(CD)๋ ์ธํ๋ผ ๋ณ๊ฒฝ, ๋ฐฐํฌ์ ๊ฐ์ ๋ฆด๋ฆฌ์ค ํ๋ก
- Suffix tree: ์คํธ๋ง ํจํด ๊ฒ์.
- R-tree: ๊ฐ์ฅ ๊ฐ๊น์ด ์ด์ ์ฐพ๊ธฐ์ ๊ฐ์ ๋ค์ฐจ์ ๊ฒ์.
-### How is an SQL statement executed in the database?
+### ๋ฐ์ดํฐ๋ฒ ์ด์ค์์ SQL ๋ฌธ์ ์ด๋ป๊ฒ ์คํ๋๋์?
์๋ ๋ค์ด์ด๊ทธ๋จ์ ๊ทธ ๊ณผ์ ์ ๋ณด์ฌ์ค๋๋ค. ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ง๋ค ์ํคํ
์ฒ๊ฐ ๋ค๋ฅด์ง๋ง ์ด ๋ค์ด์ด๊ทธ๋จ์ ๋ช ๊ฐ์ง ์ผ๋ฐ์ ์ธ ์ค๊ณ๋ฅผ ๋ณด์ฌ์ค๋๋ค.
@@ -641,7 +641,7 @@ Continuous Delivery(CD)๋ ์ธํ๋ผ ๋ณ๊ฒฝ, ๋ฐฐํฌ์ ๊ฐ์ ๋ฆด๋ฆฌ์ค ํ๋ก
8๋จ๊ณ - ํธ๋์ญ์
์ด ์งํ๋๋ ๋์ ๋ฐ์ดํฐ๋ ์ ๊ฒจ ์์ต๋๋ค. ์ด๋ lock manager์ ์ํด ๋ณด์ฅ๋ฉ๋๋ค. ๋ํ ํธ๋์ญ์
์ ACID ํ๋กํผํฐ๋ ๋ณด์ฅํฉ๋๋ค.
-### CAP theorem
+### CAP ์ ๋ฆฌ
CAP ์ ๋ฆฌ๋ ์ปดํจํฐ ๊ณผํ์์ ๊ฐ์ฅ ์ ๋ช
ํ ์ฉ์ด ์ค ํ๋์ด์ง๋ง ๊ฐ๋ฐ์๋ง๋ค ์ดํดํ๋ ๋ฐ๊ฐ ๋ค๋ฅผ ์ ์์ต๋๋ค. ์ด ์ฉ์ด๊ฐ ๋ฌด์์ด๋ฉฐ ์ ํผ๋์ค๋ฌ์ธ ์ ์๋์ง ์ดํด๋ณด๊ฒ ์ต๋๋ค.
@@ -669,14 +669,14 @@ CAP ์ ๋ฆฌ์ ๋ฐ๋ฅด๋ฉด ๋ถ์ฐ ์์คํ
์ ์ด ์ธ ๊ฐ์ง ๋ณด์ฅ ์ค ๋ ๊ฐ์ง
์ ์ถฉ์์ ๋
ผ์ํ ์ ์๋ค๋ ์ ์์ ์ฌ์ ํ ์ ์ฉํ๋ค๊ณ ์๊ฐํ์ง๋ง, ์ด๋ ์ผ๋ถ๋ถ์ผ ๋ฟ์
๋๋ค. ์ฌ๋ฐ๋ฅธ ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ฅผ ์ ํํ๋ ค๋ฉด ๋ ๊น์ด ํ๊ณ ๋ค์ด์ผ ํฉ๋๋ค.
-### Types of Memory and Storage
+### ๋ฉ๋ชจ๋ฆฌ ๋ฐ ์คํ ๋ฆฌ์ง์ ์ข
๋ฅ
-### Visualizing a SQL query
+### SQL ์ฟผ๋ฆฌ ์๊ฐํ
@@ -696,7 +696,7 @@ SQL ์คํ์ ๋งค์ฐ ๋ณต์กํ๋ฉฐ ๋ค์๊ณผ ๊ฐ์ ๋ง์ ๊ณ ๋ ค ์ฌํญ์ ํฌ
- ๋์์ฑ ์ ์ด
- ํธ๋์ญ์
๊ด๋ฆฌ
-### SQL language
+### SQL ์ธ์ด
1986๋
, SQL(Structured Query Language)์ด ํ์ค์ด ๋์์ต๋๋ค. ๊ทธ ํ 40๋
๋์ ๊ด๊ณํ ๋ฐ์ดํฐ๋ฒ ์ด์ค ๊ด๋ฆฌ ์์คํ
์์ ๊ฐ์ฅ ๋ง์ด ์ฌ์ฉ๋๋ ์ธ์ด๊ฐ ๋์์ต๋๋ค. ์ต์ ํ์ค(ANSI SQL 2016)์ ์ฝ๋ ๋ฐ๋ ๋ง์ ์๊ฐ์ด ์์๋ ์ ์์ต๋๋ค. ์ด๋ป๊ฒ ๋ฐฐ์ธ ์ ์์๊น์?
@@ -714,9 +714,9 @@ SQL ์ธ์ด์๋ 5๊ฐ์ง ๊ตฌ์ฑ ์์๊ฐ ์์ต๋๋ค.
๋ฐฑ์๋ ์์ง๋์ด์ ๊ฒฝ์ฐ ๋๋ถ๋ถ์ ์์์ผ ํ ์๋ ์์ต๋๋ค. ๋ฐ์ดํฐ ๋ถ์๊ฐ๋ผ๋ฉด DQL์ ์ ์ดํดํด์ผ ํ ์๋ ์์ต๋๋ค. ์์ ์๊ฒ ๊ฐ์ฅ ๊ด๋ จ์ฑ์ด ๋์ ์ฃผ์ ๋ฅผ ์ ํํ์ธ์.
-## Cache
+## ์บ์
-### Data is cached everywhere
+### ๋ฐ์ดํฐ๋ ์ด๋์๋ ์บ์๋ฉ๋๋ค
์ด ๋ค์ด์ด๊ทธ๋จ์ ์ผ๋ฐ์ ์ธ ์ํคํ
์ฒ์์ ๋ฐ์ดํฐ๋ฅผ ์บ์ํ๋ ์์น๋ฅผ ๋ณด์ฌ์ค๋๋ค.
@@ -741,7 +741,7 @@ SQL ์ธ์ด์๋ 5๊ฐ์ง ๊ตฌ์ฑ ์์๊ฐ ์์ต๋๋ค.
- Transaction log: ๋ชจ๋ ํธ๋์ญ์
๊ณผ ๋ฐ์ดํฐ๋ฒ ์ด์ค ์
๋ฐ์ดํธ ๊ธฐ๋กํฉ๋๋ค.
- Replication Log: ๋ฐ์ดํฐ๋ฒ ์ด์ค ํด๋ฌ์คํฐ์ ๋ณต์ ์ํ๋ฅผ ๊ธฐ๋กํ๋ ๋ฐ ์ฌ์ฉ๋ฉ๋๋ค.
-### Why is Redis so fast?
+### Redis๋ ์ ๋น ๋ฅธ๊ฐ์?
์๋ ๋ค์ด์ด๊ทธ๋จ๊ณผ ๊ฐ์ด 3๊ฐ์ง ์ฃผ์ ์ด์ ๊ฐ ์์ต๋๋ค.
@@ -758,7 +758,7 @@ Question: Another popular in-memory store is Memcached. Do you know the differen
You might have noticed the style of this diagram is different from my previous posts. Please let me know which one you prefer.
-### How can Redis be used?
+### Redis๋ ์ด๋ป๊ฒ ์ฌ์ฉํ๋์?
@@ -809,7 +809,7 @@ Redis can be used in a variety of scenarios as shown in the diagram.
We can use ZSet to sort the articles.
-### Top caching strategies
+### ์ฃผ์ ์บ์ฑ ์ ๋ต
Designing large-scale systems usually requires careful consideration of caching.
Below are five caching strategies that are frequently utilized.
@@ -820,9 +820,9 @@ Below are five caching strategies that are frequently utilized.
-## Microservice architecture
+## ๋ง์ดํฌ๋ก์๋น์ค ์ํคํ
์ฒ
-### What does a typical microservice architecture look like?
+### ์ผ๋ฐ์ ์ธ ๋ง์ดํฌ๋ก์๋น์ค ์ํคํ
์ฒ๋ ์ด๋ค ๋ชจ์ต์ผ๊น์?
@@ -845,7 +845,7 @@ Benefits of microservices:
- Each domain can be independently maintained by a dedicated team.
- Business requirements can be customized in each domain and better supported, as a result.
-### Microservice Best Practices
+### ๋ง์ดํฌ๋ก์๋น์ค ๋ชจ๋ฒ์ฌ๋ก
A picture is worth a thousand words: 9 best practices for developing microservices.
@@ -866,7 +866,7 @@ When we develop microservices, we need to follow the following best practices:
8. Design micro frontend
9. Orchestrating microservices
-### What tech stack is commonly used for microservices?
+### ๋ง์ดํฌ๋ก์๋น์ค์ ์ผ๋ฐ์ ์ผ๋ก ์ฌ์ฉํ๋ ๊ธฐ์ ์คํ์ ๋ฌด์์ธ๊ฐ์
Below you will find a diagram showing the microservice tech stack, both for the development phase and for production.
@@ -891,7 +891,7 @@ Cache and Full-text Search - Redis is a common choice for caching key-value pair
- Persistence - We can use MySQL or PostgreSQL for a relational database, and Amazon S3 for object store. We can also use Cassandra for the wide-column store if necessary.
- Management & Monitoring - To manage so many microservices, the common Ops tools include Prometheus, Elastic Stack, and Kubernetes.
-### Why is Kafka fast
+### ์นดํ์นด๊ฐ ๋น ๋ฅธ ์ด์
There are many design decisions that contributed to Kafkaโs performance. In this post, weโll focus on two. We think these two carried the most weight.
@@ -926,7 +926,7 @@ The diagram illustrates how the data is transmitted between producer and consume
Zero copy is a shortcut to save the multiple data copies between application context and kernel context.
-## Payment systems
+## ๊ฒฐ์ ์์คํ
### How to learn payment systems?
From 8c9a6ef405b989fe0d5fe9f7913f81a73019390c Mon Sep 17 00:00:00 2001
From: Deadintegral
Date: Tue, 30 Jan 2024 21:24:25 +0900
Subject: [PATCH 07/16] docs: translate to microservices architecture
---
translations/README-kr.md | 142 +++++++++++++++++++-------------------
1 file changed, 71 insertions(+), 71 deletions(-)
diff --git a/translations/README-kr.md b/translations/README-kr.md
index 80ed9d3..3f99651 100644
--- a/translations/README-kr.md
+++ b/translations/README-kr.md
@@ -285,7 +285,7 @@ Connection Pool
- HTTP 2.0์ 2015๋
์ ๋ฐํ๋์์ต๋๋ค. ์ด๋ ์์ฒญ ๋ค์คํ๋ฅผ ํตํด HOL ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ์ฌ ์์ฉ ๊ณ์ธต์์ HOL ์ฐจ๋จ์ ์ ๊ฑฐํ์ง๋ง, ์ ์ก(TCP) ๊ณ์ธต์๋ ์ฌ์ ํ HOL์ด ์กด์ฌํฉ๋๋ค.
- ๋ค์ด์ด๊ทธ๋จ์์ ๋ณผ ์ ์๋ฏ์ด HTTP 2.0์ ๋์ผํ TCP ์ปค๋ฅ์
์ ์๋ก ๋ค๋ฅธ HTTP ๊ตํ์ ๋ค์คํํ ์ ์๋ ์ถ์ํ ๊ฐ๋
์ธ HTTP "steam"์ ๋์
ํ์ต๋๋ค. ๊ฐ ์คํธ๋ฆผ์ ์์๋๋ก ์ ์กํ ํ์๋ ์์ต๋๋ค.
+ ๋ค์ด์ด๊ทธ๋จ์์ ๋ณผ ์ ์๋ฏ์ด HTTP 2.0์ ๋์ผํ TCP ์ปค๋ฅ์
์ ์๋ก ๋ค๋ฅธ HTTP ๊ตํ์ ๋ค์คํํ ์ ์๋ ์ถ์ํ ๊ฐ๋
์ธ HTTP "stream"์ ๋์
ํ์ต๋๋ค. ๊ฐ ์คํธ๋ฆผ์ ์์๋๋ก ์ ์กํ ํ์๋ ์์ต๋๋ค.
- HTTP 3.0 ์ด์์ 2020๋
์ ๋ฐํ๋์์ต๋๋ค. HTTP 2.0์ ํ์ ๋ฒ์ ์ผ๋ก ์ ์๋์์ต๋๋ค. ๊ธฐ๋ณธ ํธ๋์คํฌํธ ํ๋กํ ์ฝ๋ก TCP ๋์ QUIC์ ์ฌ์ฉํ๋ฏ๋ก ์ ์ก ๊ณ์ธต์์ HOL ์ฐจ๋จ์ด ์ ๊ฑฐ๋ฉ๋๋ค.
@@ -750,13 +750,13 @@ SQL ์ธ์ด์๋ 5๊ฐ์ง ๊ตฌ์ฑ ์์๊ฐ ์์ต๋๋ค.
-1. Redis is a RAM-based data store. RAM access is at least 1000 times faster than random disk access.
-2. Redis leverages IO multiplexing and single-threaded execution loop for execution efficiency.
-3. Redis leverages several efficient lower-level data structures.
+1. Redis๋ RAM ๊ธฐ๋ฐ ๋ฐ์ดํฐ ์ ์ฅ์์
๋๋ค. RAM ์ก์ธ์ค๋ ์์์ ๋์คํฌ ์ก์ธ์ค๋ณด๋ค ์ต์ 1000๋ฐฐ ์ด์ ๋น ๋ฆ
๋๋ค.
+2. Redis๋ ์คํ ํจ์จ์ฑ์ ์ํด IO ๋ฉํฐํ๋ ์ฑ๊ณผ ์ฑ๊ธ ์ค๋ ๋ ์ต์คํ์
๋ฃจํ๋ฅผ ํ์ฉํฉ๋๋ค.
+3. Redis๋ ๋ช ๊ฐ์ง ํจ์จ์ ์ธ ๋ก์ฐ ๋ ๋ฒจ ๋ฐ์ดํฐ ๊ตฌ์กฐ๋ฅผ ํ์ฉํฉ๋๋ค.
-Question: Another popular in-memory store is Memcached. Do you know the differences between Redis and Memcached?
+์ง๋ฌธ: ๋ ๋ค๋ฅธ ์ธ๊ธฐ ์๋ ์ธ๋ฉ๋ชจ๋ฆฌ ์ ์ฅ์๋ Memcached์
๋๋ค. Redis์ Memcached์ ์ฐจ์ด์ ์ ์๊ณ ์๋์?
-You might have noticed the style of this diagram is different from my previous posts. Please let me know which one you prefer.
+์ด ๋ค์ด์ด๊ทธ๋จ์ ์คํ์ผ์ด ์ด์ ๊ฒ์๋ฌผ๊ณผ ๋ค๋ฅด๋ค๋ ๊ฒ์ ๋์น์ฑ์
จ์ ๊ฒ์
๋๋ค. ์ด๋ ์ชฝ์ ์ ํธํ์๋์ง ์๋ ค์ฃผ์ธ์.
### Redis๋ ์ด๋ป๊ฒ ์ฌ์ฉํ๋์?
@@ -765,54 +765,54 @@ You might have noticed the style of this diagram is different from my previous p
-There is more to Redis than just caching.
+Redis์๋ ๋จ์ํ ์บ์ฑ ์ด์์ ๊ธฐ๋ฅ์ด ์์ต๋๋ค.
-Redis can be used in a variety of scenarios as shown in the diagram.
+Redis๋ ๋ค์ด์ด๊ทธ๋จ์ ํ์๋ ๊ฒ์ฒ๋ผ ๋ค์ํ ์๋๋ฆฌ์ค์์ ์ฌ์ฉํ ์ ์์ต๋๋ค.
- Session
- We can use Redis to share user session data among different services.
+ Redis๋ฅผ ์ฌ์ฉํ์ฌ ์ฌ๋ฌ ์๋น์ค ๊ฐ์ ์ฌ์ฉ์ ์ธ์
๋ฐ์ดํฐ๋ฅผ ๊ณต์ ํ ์ ์์ต๋๋ค.
- Cache
- We can use Redis to cache objects or pages, especially for hotspot data.
+ ํนํ ํซ์คํ ๋ฐ์ดํฐ์ ๊ฒฝ์ฐ Redis๋ฅผ ์ฌ์ฉํ์ฌ ๊ฐ์ฒด๋ ํ์ด์ง๋ฅผ ์บ์ํ ์ ์์ต๋๋ค.
- Distributed lock
- We can use a Redis string to acquire locks among distributed services.
+ Redis ์คํธ๋ง์ ์ฌ์ฉํ์ฌ ๋ถ์ฐ ์๋น์ค ๊ฐ์ lock์ ํ๋ํ ์ ์์ต๋๋ค.
- Counter
- We can count how many likes or how many reads for articles.
+ ์ข์์ ์, ์กฐํ์๋ฅผ ๊ณ์ฐํ ์ ์์ต๋๋ค.
- Rate limiter
- We can apply a rate limiter for certain user IPs.
+ ํน์ ์ฌ์ฉ์ IP์ ๋ํด rate limiter๋ฅผ ์ ์ฉํ ์ ์์ต๋๋ค.
- Global ID generator
- We can use Redis Int for global ID.
+ ๊ธ๋ก๋ฒ ID์ Redis Int๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค.
- Shopping cart
- We can use Redis Hash to represent key-value pairs in a shopping cart.
+ Redis ํด์๋ฅผ ์ฌ์ฉํ์ฌ ์ฅ๋ฐ๊ตฌ๋์ key-value ์์ ๋ํ๋ผ ์ ์์ต๋๋ค.
- Calculate user retention
- We can use Bitmap to represent the user login daily and calculate user retention.
+ ๋นํธ๋งต์ ์ฌ์ฉํ์ฌ ๋งค์ผ ๋ก๊ทธ์ธํ๋ ์ฌ์ฉ์๋ฅผ ํ์ํ๊ณ ์ฌ์ฉ์ ๋ฆฌํ
์
์ ๊ณ์ฐํ ์ ์์ต๋๋ค.
- Message queue
- We can use List for a message queue.
+ ๋ฉ์์ง ํ์ ๋ฆฌ์คํธ๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค.
- Ranking
- We can use ZSet to sort the articles.
+ ZSet์ ์ฌ์ฉํ์ฌ ์ํฐํด์ ์ ๋ ฌํ ์ ์์ต๋๋ค.
### ์ฃผ์ ์บ์ฑ ์ ๋ต
-Designing large-scale systems usually requires careful consideration of caching.
-Below are five caching strategies that are frequently utilized.
+๋๊ท๋ชจ ์์คํ
์ ์ค๊ณํ ๋๋ ์ผ๋ฐ์ ์ผ๋ก ์บ์ฑ์ ์ ์คํ๊ฒ ๊ณ ๋ คํด์ผ ํฉ๋๋ค.
+๋ค์์ ์์ฃผ ํ์ฉ๋๋ 5๊ฐ์ง ์บ์ฑ ์ ๋ต์
๋๋ค.
@@ -829,46 +829,46 @@ Below are five caching strategies that are frequently utilized.
-The diagram below shows a typical microservice architecture.
+์๋ ๋ค์ด์ด๊ทธ๋จ์ ์ผ๋ฐ์ ์ธ ๋ง์ดํฌ๋ก์๋น์ค ์ํคํ
์ฒ๋ฅผ ๋ณด์ฌ์ค๋๋ค.
-- Load Balancer: This distributes incoming traffic across multiple backend services.
-- CDN (Content Delivery Network): CDN is a group of geographically distributed servers that hold static content for faster delivery. The clients look for content in CDN first, then progress to backend services.
-- API Gateway: This handles incoming requests and routes them to the relevant services. It talks to the identity provider and service discovery.
-- Identity Provider: This handles authentication and authorization for users.
-- Service Registry & Discovery: Microservice registration and discovery happen in this component, and the API gateway looks for relevant services in this component to talk to.
-- Management: This component is responsible for monitoring the services.
-- Microservices: Microservices are designed and deployed in different domains. Each domain has its own database. The API gateway talks to the microservices via REST API or other protocols, and the microservices within the same domain talk to each other using RPC (Remote Procedure Call).
+- Load Balancer: ์ด๋ ๊ฒ ํ๋ฉด ๋ค์ด์ค๋ ํธ๋ํฝ์ด ์ฌ๋ฌ ๋ฐฑ์๋ ์๋น์ค์ ๋ถ์ฐ๋ฉ๋๋ค.
+- CDN (Content Delivery Network): CDN์ ๋ ๋น ๋ฅธ ์ ์ก์ ์ํด ์ ์ ์ฝํ
์ธ ๋ฅผ ๋ณด๊ดํ๋ ์ง๋ฆฌ์ ์ผ๋ก ๋ถ์ฐ๋ ์๋ฒ ๊ทธ๋ฃน์
๋๋ค. ํด๋ผ์ด์ธํธ๋ ๋จผ์ CDN์์ ์ฝํ
์ธ ๋ฅผ ์ฐพ์ ๋ค์ ๋ฐฑ์๋ ์๋น์ค๋ก ์ด๋ํฉ๋๋ค.
+- API Gateway: ์์ ์์ฒญ์ ์ฒ๋ฆฌํ๊ณ ๊ด๋ จ ์๋น์ค๋ก ๋ผ์ฐํ
ํฉ๋๋ค. ID ๊ณต๊ธ์์ ํต์ ํ๊ณ ์๋น์ค๋ฅผ ๊ฒ์ํฉ๋๋ค.
+- Identity Provider: ์ ์ ์ ๋ํ ์ธ์ฆ๊ณผ ์ธ๊ฐ๋ฅผ ์ฒ๋ฆฌํฉ๋๋ค.
+- Service Registry & Discovery: ์ด ์ปดํฌ๋ํธ์์ ๋ง์ดํฌ๋ก์๋น์ค ๋ฑ๋ก ๋ฐ ๊ฒ์์ด ์ด๋ฃจ์ด์ง๊ณ , API ๊ฒ์ดํธ์จ์ด๋ ์ด ์ปดํฌ๋ํธ์์ ๋ํํ ๊ด๋ จ ์๋น์ค๋ฅผ ์ฐพ์ต๋๋ค.
+- Management: ์ด ์ปดํฌ๋ํธ๋ ์๋น์ค ๋ชจ๋ํฐ๋ง์ ๋ด๋นํฉ๋๋ค.
+- Microservices: ๋ง์ดํฌ๋ก์๋น์ค๋ ์๋ก ๋ค๋ฅธ ๋๋ฉ์ธ์์ ์ค๊ณ ๋ฐ ๋ฐฐํฌ๋ฉ๋๋ค. ๊ฐ ๋๋ฉ์ธ์๋ ์์ฒด ๋ฐ์ดํฐ๋ฒ ์ด์ค๊ฐ ์์ต๋๋ค. API ๊ฒ์ดํธ์จ์ด๋ REST API ๋๋ ๊ธฐํ ํ๋กํ ์ฝ์ ํตํด ๋ง์ดํฌ๋ก์๋น์ค์ ํต์ ํ๊ณ , ๋์ผํ ๋๋ฉ์ธ ๋ด์ ๋ง์ดํฌ๋ก์๋น์ค๋ RPC(Remote Procedure Call)๋ฅผ ์ฌ์ฉํ์ฌ ์๋ก ํต์ ํฉ๋๋ค.
-Benefits of microservices:
+๋ง์ดํฌ๋ก์๋น์ค์ ์ด์
-- They can be quickly designed, deployed, and horizontally scaled.
-- Each domain can be independently maintained by a dedicated team.
-- Business requirements can be customized in each domain and better supported, as a result.
+- ๋น ๋ฅด๊ฒ ์ค๊ณ, ๋ฐฐํฌํ๊ณ ์ํ์ ์ผ๋ก ํ์ฅํ ์ ์์ต๋๋ค.
+- ๊ฐ ๋๋ฉ์ธ์ ์ ๋ด ํ์์ ๋
๋ฆฝ์ ์ผ๋ก ๊ด๋ฆฌํ ์ ์์ต๋๋ค.
+- ๊ฒฐ๊ณผ์ ์ผ๋ก ๊ฐ ๋๋ฉ์ธ์์ ๋น์ฆ๋์ค ์๊ตฌ ์ฌํญ์ ์ปค์คํฐ๋ง์ด์ฆํ๊ณ ๋ ๋์ ์ง์์ ์ ๊ณตํ ์ ์์ต๋๋ค.
### ๋ง์ดํฌ๋ก์๋น์ค ๋ชจ๋ฒ์ฌ๋ก
-A picture is worth a thousand words: 9 best practices for developing microservices.
+์ฌ์ง ํ ์ฅ์ด ์ฒ ๋ง๋ ๋ง๋ณด๋ค ๋ซ์ต๋๋ค: ๋ง์ดํฌ๋ก์๋น์ค ๊ฐ๋ฐ์ ์ํ 9๊ฐ์ง ๋ชจ๋ฒ ์ฌ๋ก.
-When we develop microservices, we need to follow the following best practices:
-
-1. Use separate data storage for each microservice
-2. Keep code at a similar level of maturity
-3. Separate build for each microservice
-4. Assign each microservice with a single responsibility
-5. Deploy into containers
-6. Design stateless services
-7. Adopt domain-driven design
-8. Design micro frontend
-9. Orchestrating microservices
+๋ง์ดํฌ๋ก์๋น์ค๋ฅผ ๊ฐ๋ฐํ ๋๋ ๋ค์๊ณผ ๊ฐ์ ๋ชจ๋ฒ ์ฌ๋ก๋ฅผ ๋ฐ๋ผ์ผ ํฉ๋๋ค.
+
+1. ๊ฐ ๋ง์ดํฌ๋ก์๋น์ค๋ง๋ค ๋ณ๋์ ๋ฐ์ดํฐ ์คํ ๋ฆฌ์ง ์ฌ์ฉ
+2. ์ฝ๋์ ์์ฑ๋๋ฅผ ๋น์ทํ ์์ค์ผ๋ก ์ ์ง
+3. ๊ฐ ๋ง์ดํฌ๋ก์๋น์ค๋ง๋ค ๋ณ๋๋ก ๋น๋
+4. ๊ฐ ๋ง์ดํฌ๋ก์๋น์ค์ ๋จ์ผ ์ฑ
์ ํ ๋น
+5. ์ปจํ
์ด๋์ ๋ฐฐํฌ
+6. ์คํ
์ดํธ๋ฆฌ์ค ์๋น์ค ์ค๊ณ
+7. ๋๋ฉ์ธ ๋๋ฆฌ๋ธ ์ค๊ณ ๋์
+8. ๋ง์ดํฌ๋ก ํ๋ก ํธ์๋ ์ค๊ณ
+9. ๋ง์ดํฌ๋ก์๋น์ค ์ค์ผ์คํธ๋ ์ด์
### ๋ง์ดํฌ๋ก์๋น์ค์ ์ผ๋ฐ์ ์ผ๋ก ์ฌ์ฉํ๋ ๊ธฐ์ ์คํ์ ๋ฌด์์ธ๊ฐ์
-Below you will find a diagram showing the microservice tech stack, both for the development phase and for production.
+์๋์์ ๊ฐ๋ฐ ๋จ๊ณ์ ํ๋ก๋์
๋จ๊ณ์ ๋ง์ดํฌ๋ก์๋น์ค ๊ธฐ์ ์คํ์ ๋ณด์ฌ์ฃผ๋ ๋ค์ด์ด๊ทธ๋จ์ ํ์ธํ ์ ์์ต๋๋ค.
@@ -877,54 +877,54 @@ Below you will find a diagram showing the microservice tech stack, both for the
โถ๏ธ ๐๐ซ๐-๐๐ซ๐จ๐๐ฎ๐๐ญ๐ข๐จ๐ง
-- Define API - This establishes a contract between frontend and backend. We can use Postman or OpenAPI for this.
-- Development - Node.js or react is popular for frontend development, and java/python/go for backend development. Also, we need to change the configurations in the API gateway according to API definitions.
-- Continuous Integration - JUnit and Jenkins for automated testing. The code is packaged into a Docker image and deployed as microservices.
+- Define API - ์ด๋ ๊ฒ ํ๋ฉด ํ๋ก ํธ์๋์ ๋ฐฑ์๋ ๊ฐ์ ๊ณ์ฝ์ด ์ฑ๋ฆฝ๋ฉ๋๋ค. ์ด๋ฅผ ์ํด Postman, OpenAPI๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค.
+- Development - ํ๋ก ํธ์๋ ๊ฐ๋ฐ์๋ Node.js๋ react๊ฐ, ๋ฐฑ์๋ ๊ฐ๋ฐ์๋ ์๋ฐ/ํ์ด์ฌ/go๊ฐ ๋ง์ด ์ฌ์ฉ๋ฉ๋๋ค. ๋ํ API ์ ์์ ๋ฐ๋ผ API ๊ฒ์ดํธ์จ์ด์ ๊ตฌ์ฑ์ ๋ณ๊ฒฝํด์ผ ํฉ๋๋ค.
+- Continuous Integration - ์๋ํ๋ ํ
์คํธ๋ฅผ ์ํด JUnit๊ณผ Jenkins๋ฅผ ์ฌ์ฉํฉ๋๋ค. ์ฝ๋๋ Docker ์ด๋ฏธ์ง๋ก ํจํค์ง๋์ด ๋ง์ดํฌ๋ก์๋น์ค๋ก ๋ฐฐํฌ๋ฉ๋๋ค.
โถ๏ธ ๐๐ซ๐จ๐๐ฎ๐๐ญ๐ข๐จ๐ง
-- NGinx is a common choice for load balancers. Cloudflare provides CDN (Content Delivery Network).
-- API Gateway - We can use spring boot for the gateway, and use Eureka/Zookeeper for service discovery.
-- The microservices are deployed on clouds. We have options among AWS, Microsoft Azure, or Google GCP.
-Cache and Full-text Search - Redis is a common choice for caching key-value pairs. Elasticsearch is used for full-text search.
-- Communications - For services to talk to each other, we can use messaging infra Kafka or RPC.
-- Persistence - We can use MySQL or PostgreSQL for a relational database, and Amazon S3 for object store. We can also use Cassandra for the wide-column store if necessary.
-- Management & Monitoring - To manage so many microservices, the common Ops tools include Prometheus, Elastic Stack, and Kubernetes.
+- ๋ก๋ ๋ฐธ๋ฐ์์๋ NGinx๊ฐ ์ผ๋ฐ์ ์ผ๋ก ์ ํ๋ฉ๋๋ค. Cloudflare๋ CDN(Content Delivery Network)์ ์ ๊ณตํฉ๋๋ค.
+- API Gateway - ๊ฒ์ดํธ์จ์ด์๋ ์คํ๋ง ๋ถํธ๋ฅผ ์ฌ์ฉํ๊ณ , ์๋น์ค ๊ฒ์์๋ Eureka/Zookeeper๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค.
+- ๋ง์ดํฌ๋ก์๋น์ค๋ ํด๋ผ์ฐ๋์ ๋ฐฐํฌ๋ฉ๋๋ค. AWS, Microsoft Azure, Google GCP ์ค์์ ์ ํํ ์ ์์ต๋๋ค.
+Cache and Full-text Search - Redis๋ key-value ์์ ์บ์ฑํ๊ธฐ ์ํ ์ผ๋ฐ์ ์ธ ์ ํ์
๋๋ค. ํ ํ
์คํธ ์์น์๋ Elasticsearch๊ฐ ์ฌ์ฉ๋ฉ๋๋ค.
+- Communications - ์๋น์ค๊ฐ ์๋ก ํต์ ํ๊ธฐ ์ํด์๋ ๋ฉ์์ง ์ธํ๋ผ๋ก Kafka ํน์ RPC๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค.
+- Persistence - ๊ด๊ณํ ๋ฐ์ดํฐ๋ฒ ์ด์ค์๋ MySQL ๋๋ PostgreSQL์ ์ฌ์ฉํ ์ ์์ผ๋ฉฐ, ๊ฐ์ฒด ์ ์ฅ์์๋ Amazon S3์ ์ฌ์ฉํ ์ ์์ต๋๋ค. ํ์ํ ๊ฒฝ์ฐ wide-column ์ ์ฅ์๋ก Cassandra๋ฅผ ์ฌ์ฉํ ์๋ ์์ต๋๋ค.
+- Management & Monitoring - ์๋ง์ ๋ง์ดํฌ๋ก์๋น์ค๋ฅผ ๊ด๋ฆฌํ๊ธฐ ์ํ ์ผ๋ฐ์ ์ธ ์ด์ ๋๊ตฌ๋ก Prometheus, Elastic Stack, Kubernetes๊ฐ ์์ต๋๋ค.
### ์นดํ์นด๊ฐ ๋น ๋ฅธ ์ด์
-There are many design decisions that contributed to Kafkaโs performance. In this post, weโll focus on two. We think these two carried the most weight.
+์นดํ์นด์ ์ฑ๋ฅ์ ๊ธฐ์ฌํ ๋ง์ ๋์์ธ ๊ฒฐ์ ์ด ์์ต๋๋ค. ์ด ๊ธ์์๋ ๋ ๊ฐ์ง์ ์ด์ ์ ๋ง์ถ๊ฒ ์ต๋๋ค. ์ด ๋ ๊ฐ์ง๊ฐ ๊ฐ์ฅ ํฐ ๋น์ค์ ์ฐจ์งํ๋ค๊ณ ์๊ฐํฉ๋๋ค.
-1. The first one is Kafkaโs reliance on Sequential I/O.
-2. The second design choice that gives Kafka its performance advantage is its focus on efficiency: zero copy principle.
+1. ์ฒซ ๋ฒ์งธ๋ ์นดํ์นด๊ฐ ์์ฐจ์ I/O์ ์์กดํ๋ค๋ ์ ์
๋๋ค.
+2. ์นดํ์นด์ ์ฑ๋ฅ ์ด์ ์ ์ ๊ณตํ๋ ๋ ๋ฒ์งธ ์ค๊ณ ์ ํ์ ํจ์จ์ฑ์ ์ด์ ์ ๋ง์ถ ์ ๋ก ์นดํผ ์์น์
๋๋ค.
-The diagram illustrates how the data is transmitted between producer and consumer, and what zero-copy means.
+์ด ๋ค์ด์ด๊ทธ๋จ์ ํ๋ก๋์์ ์ปจ์๋จธ ๊ฐ์ ๋ฐ์ดํฐ๊ฐ ์ ์ก๋๋ ๋ฐฉ์๊ณผ ์ ๋ก ์นดํผ์ ์๋ฏธ๋ฅผ ์ค๋ช
ํฉ๋๋ค.
-- Step 1.1 - 1.3: Producer writes data to the disk
-- Step 2: Consumer reads data without zero-copy
+- 1.1 - 1.3๋จ๊ณ: ํ๋ก๋์๊ฐ ๋์คํฌ์ ๋ฐ์ดํฐ ์ฐ๊ธฐ
+- 2๋จ๊ณ: ์ปจ์๋จธ๊ฐ ์ ๋ก ์นดํผ ์์ด ๋ฐ์ดํฐ ์ฝ๊ธฐ
-2.1 The data is loaded from disk to OS cache
+2.1 ๋ฐ์ดํฐ๊ฐ ๋์คํฌ์์ OS ์บ์๋ก ๋ก๋๋ฉ๋๋ค.
-2.2 The data is copied from OS cache to Kafka application
+2.2 ๋ฐ์ดํฐ๊ฐ OS ์บ์์์ ์นดํ์นด ์ ํ๋ฆฌ์ผ์ด์
์ผ๋ก ๋ณต์ฌ๋ฉ๋๋ค.
-2.3 Kafka application copies the data into the socket buffer
+2.3 ์นดํ์นด ์ ํ๋ฆฌ์ผ์ด์
์ด ๋ฐ์ดํฐ๋ฅผ ์์ผ ๋ฒํผ์ ๋ณต์ฌํฉ๋๋ค.
-2.4 The data is copied from socket buffer to network card
+2.4 ๋ฐ์ดํฐ๊ฐ ์์ผ ๋ฒํผ์์ ๋คํธ์ํฌ ์นด๋๋ก ๋ณต์ฌ๋ฉ๋๋ค.
-2.5 The network card sends data out to the consumer
+2.5 ๋คํธ์ํฌ ์นด๋๊ฐ ์ปจ์๋จธ์๊ฒ ๋ฐ์ดํฐ๋ฅผ ์ ์กํฉ๋๋ค.
-- Step 3: Consumer reads data with zero-copy
+- 3๋จ๊ณ: ์ปจ์๋จธ๋ ์ ๋ก ์นดํผ๋ก ๋ฐ์ดํฐ๋ฅผ ์ฝ์ต๋๋ค.
-3.1: The data is loaded from disk to OS cache
-3.2 OS cache directly copies the data to the network card via sendfile() command
-3.3 The network card sends data out to the consumer
+3.1: ๋ฐ์ดํฐ๊ฐ ๋์คํฌ์์ OS ์บ์๋ก ๋ก๋๋ฉ๋๋ค.
+3.2 OS ์บ์๋ sendfile() ์ปค๋งจ๋๋ฅผ ํตํด ๋ฐ์ดํฐ๋ฅผ ๋คํธ์ํฌ ์นด๋์ ์ง์ ๋ณต์ฌํฉ๋๋ค.
+3.3 ๋คํธ์ํฌ ์นด๋๊ฐ ์ปจ์๋จธ์๊ฒ ๋ฐ์ดํฐ๋ฅผ ์ ์กํฉ๋๋ค.
-Zero copy is a shortcut to save the multiple data copies between application context and kernel context.
+์ ๋ก ์นดํผ๋ ์ ํ๋ฆฌ์ผ์ด์
์ปจํ
์คํธ์ ์ปค๋ ์ปจํ
์คํธ ์ฌ์ด์ ์ฌ๋ฌ ๋ฐ์ดํฐ ๋ณต์ฌ๋ณธ์ ์ ์ฅํ๋ ์์ปท์
๋๋ค.
## ๊ฒฐ์ ์์คํ
From 852b5f05392a29d0fb49c7e072cf7a1b2e0f9482 Mon Sep 17 00:00:00 2001
From: Deadintegral
Date: Wed, 31 Jan 2024 01:43:01 +0900
Subject: [PATCH 08/16] docs: translate to payment system
---
translations/README-kr.md | 74 +++++++++++++++++++--------------------
1 file changed, 37 insertions(+), 37 deletions(-)
diff --git a/translations/README-kr.md b/translations/README-kr.md
index 3f99651..03b8f32 100644
--- a/translations/README-kr.md
+++ b/translations/README-kr.md
@@ -64,10 +64,10 @@
- [๋ง์ดํฌ๋ก์๋น์ค์ ์ผ๋ฐ์ ์ผ๋ก ์ฌ์ฉํ๋ ๊ธฐ์ ์คํ์ ๋ฌด์์ธ๊ฐ์?](#๋ง์ดํฌ๋ก์๋น์ค์-์ผ๋ฐ์ ์ผ๋ก-์ฌ์ฉํ๋-๊ธฐ์ -์คํ์-๋ฌด์์ธ๊ฐ์)
- [์นดํ์นด๊ฐ ๋น ๋ฅธ ์ด์ ](#์นดํ์นด๊ฐ-๋น ๋ฅธ-์ด์ )
- [๊ฒฐ์ ์์คํ
](#๊ฒฐ์ -์์คํ
)
- - [๊ฒฐ์ ์์คํ
์ ๋ฐฐ์ฐ๋ ๋ฐฉ๋ฒ์ ๋ฌด์์ธ๊ฐ์?](#how-to-learn-payment-systems)
- - [์ ์ฉ์นด๋๋ฅผ "์ํ์์ ๊ฐ์ฅ ์์ต์ฑ์ด ๋์ ์ํ"์ด๋ผ๊ณ ๋ถ๋ฅด๋ ์ด์ ๋ ๋ฌด์์ธ๊ฐ์? ๋น์/๋ง์คํฐ์นด๋๋ ์ด๋ป๊ฒ ์์ต์ ์ฐฝ์ถํ๋์?](#why-is-the-credit-card-called-the-most-profitable-product-in-banks-how-does-visamastercard-make-money)
- - [How does VISA work when we swipe a credit card at a merchantโs shop?](#how-does-visa-work-when-we-swipe-a-credit-card-at-a-merchants-shop)
- - [์ธ๊ณ์ ๊ฒฐ์ ์์คํ
์๋ฆฌ์ฆ(1๋ถ): ์ธ๋์ ํตํฉ ๊ฒฐ์ ์ธํฐํ์ด์ค(UPI)](#payment-systems-around-the-world-series-part-1-unified-payments-interface-upi-in-india)
+ - [๊ฒฐ์ ์์คํ
์ ์ด๋ป๊ฒ ๋ฐฐ์ฐ๋์?](#๊ฒฐ์ -์์คํ
์-์ด๋ป๊ฒ-๋ฐฐ์ฐ๋์)
+ - [์ ์ฉ์นด๋๋ฅผ "์ํ์์ ๊ฐ์ฅ ์์ต์ฑ์ด ๋์ ์ํ"์ด๋ผ๊ณ ๋ถ๋ฅด๋ ์ด์ ๋ ๋ฌด์์ธ๊ฐ์? ๋น์/๋ง์คํฐ์นด๋๋ ์ด๋ป๊ฒ ์์ต์ ์ฐฝ์ถํ๋์?](#์ ์ฉ์นด๋๋ฅผ-์ํ์์-๊ฐ์ฅ-์์ต์ฑ์ด-๋์-์ํ์ด๋ผ๊ณ -๋ถ๋ฅด๋-์ด์ ๋-๋ฌด์์ธ๊ฐ์-๋น์๋ง์คํฐ์นด๋๋-์ด๋ป๊ฒ-์์ต์-์ฐฝ์ถํ๋์)
+ - [์์ ์์ ์ฐ๋ฆฌ๊ฐ ์ ์ฉ์นด๋๋ฅผ ๊ธ์ ๋, VISA๋ ์ด๋ป๊ฒ ์๋ํ๋์?](#์์ ์์-์ฐ๋ฆฌ๊ฐ-์ ์ฉ์นด๋๋ฅผ-๊ธ์-๋-visa๋-์ด๋ป๊ฒ-์๋ํ๋์)
+ - [์ธ๊ณ์ ๊ฒฐ์ ์์คํ
์๋ฆฌ์ฆ(1๋ถ): ์ธ๋์ ํตํฉ ๊ฒฐ์ ์ธํฐํ์ด์ค(UPI)](#์ธ๊ณ์-๊ฒฐ์ -์์คํ
-์๋ฆฌ์ฆ1๋ถ-์ธ๋์-ํตํฉ-๊ฒฐ์ -์ธํฐํ์ด์คupi)
- [DevOps](#devops)
- [DevOps vs. SRE vs. Platform Engineering. ๋ฌด์์ด ๋ค๋ฅธ๊ฐ์?](#devops-vs-sre-vs-platform-engineering-what-is-the-difference)
- [k8s(Kubernetes)๋ ๋ฌด์์ธ๊ฐ์?](#what-is-k8s-kubernetes)
@@ -928,83 +928,83 @@ Cache and Full-text Search - Redis๋ key-value ์์ ์บ์ฑํ๊ธฐ ์ํ ์ผ
## ๊ฒฐ์ ์์คํ
-### How to learn payment systems?
+### ๊ฒฐ์ ์์คํ
์ ์ด๋ป๊ฒ ๋ฐฐ์ฐ๋์?
-### Why is the credit card called โthe most profitable product in banksโ? How does VISA/Mastercard make money?
+### ์ ์ฉ์นด๋๋ฅผ "์ํ์์ ๊ฐ์ฅ ์์ต์ฑ์ด ๋์ ์ํ"์ด๋ผ๊ณ ๋ถ๋ฅด๋ ์ด์ ๋ ๋ฌด์์ธ๊ฐ์? ๋น์/๋ง์คํฐ์นด๋๋ ์ด๋ป๊ฒ ์์ต์ ์ฐฝ์ถํ๋์?
-The diagram below shows the economics of the credit card payment flow.
+์๋ ๋ค์ด์ด๊ทธ๋จ์ ์ ์ฉ์นด๋ ๊ฒฐ์ ํ๋ก์ฐ์ ์ด์ฝ๋
ธ๋ฏน์ค๋ฅผ ๋ณด์ฌ์ค๋๋ค.
-1. The cardholder pays a merchant $100 to buy a product.
+1.์นด๋ ์์ ์๊ฐ ์ ํ์ ๊ตฌ๋งคํ๊ธฐ ์ํด ํ๋งค์์๊ฒ 100๋ฌ๋ฌ๋ฅผ ์ง๋ถํฉ๋๋ค.
-2. The merchant benefits from the use of the credit card with higher sales volume and needs to compensate the issuer and the card network for providing the payment service. The acquiring bank sets a fee with the merchant, called the โmerchant discount fee.โ
+2.ํ๋งค์๋ ํ๋งค๋์ด ๋ง์ ์ ์ฉ์นด๋๋ฅผ ์ฌ์ฉํ์ฌ ์ด์ต์ ์ป๊ณ ๊ฒฐ์ ์๋น์ค ์ ๊ณต์ ๋ํด ๋ฐ๊ธ์ฌ์ ์นด๋ ๋คํธ์ํฌ์ ๋ณด์์ ํด์ผ ํฉ๋๋ค. ๋งค์
์ํ์ ํ๋งค์์ "merchant discount fee"๋ผ๊ณ ํ๋ ์์๋ฃ๋ฅผ ์ค์ ํฉ๋๋ค.
-3 - 4. The acquiring bank keeps $0.25 as the acquiring markup, and $1.75 is paid to the issuing bank as the interchange fee. The merchant discount fee should cover the interchange fee.
+3 - 4. ๋งค์
์ํ์ ๊ตํ ์์๋ฃ๋ก $0.25๋ฅผ ์์ ํ๊ณ , $1.75๋ ํ์ ์์๋ฃ๋ก ๋ฐ๊ธ ์ํ์ ์ง๋ถํฉ๋๋ค. merchant discount fee๋ก ํ์ ์์๋ฃ๋ฅผ ์ถฉ๋นํด์ผ ํฉ๋๋ค.
- The interchange fee is set by the card network because it is less efficient for each issuing bank to negotiate fees with each merchant.
+ ๊ฐ ๋ฐ๊ธ ์ํ์ด ๊ฐ ๊ฐ๋งน์ ๊ณผ ์์๋ฃ๋ฅผ ํ์ํ๋ ๊ฒ์ด ํจ์จ์ ์ด์ง ์๊ธฐ ๋๋ฌธ์ ๊ตํ ์์๋ฃ๋ ์นด๋ ๋คํธ์ํฌ์์ ์ค์ ํฉ๋๋ค.
-5. The card network sets up the network assessments and fees with each bank, which pays the card network for its services every month. For example, VISA charges a 0.11% assessment, plus a $0.0195 usage fee, for every swipe.
+5.์นด๋ ๋คํธ์ํฌ๋ ๊ฐ ์ํ๊ณผ network assessments and fees๋ฅผ ์ค์ ํ๊ณ , ์ํ์ ๋งค๋ฌ ์นด๋ ๋คํธ์ํฌ์ ์๋น์ค ๋น์ฉ์ ์ง๋ถํฉ๋๋ค. ์๋ฅผ ๋ค์ด, VISA๋ ์ค์์ดํํ ๋๋ง๋ค 0.11%์ ํ๊ฐ ์์๋ฃ์ $0.0195์ ์ฌ์ฉ ์์๋ฃ๋ฅผ ๋ถ๊ณผํฉ๋๋ค.
-6. The cardholder pays the issuing bank for its services.
+6.์นด๋ ์์ ์๋ ๋ฐ๊ธ ์ํ์ ์๋น์ค ๋น์ฉ์ ์ง๋ถํฉ๋๋ค.
-Why should the issuing bank be compensated?
+์ ๋ฐ๊ธ ์ํ์ด ๋ณด์์ ๋ฐ์์ผ ํ๋์?
-- The issuer pays the merchant even if the cardholder fails to pay the issuer.
-- The issuer pays the merchant before the cardholder pays the issuer.
-- The issuer has other operating costs, including managing customer accounts, providing statements, fraud detection, risk management, clearing & settlement, etc.
+- ์นด๋ ์์ ์ฃผ๊ฐ ๋ฐ๊ธ์ฌ์ ๋๊ธ์ ์ง๋ถํ์ง ์๋๋ผ๋ ๋ฐ๊ธ์ฌ๋ ํ๋งค์์๊ฒ ๋๊ธ์ ์ง๋ถํฉ๋๋ค.
+- ์นด๋ ์์ง์๊ฐ ๋ฐ๊ธ์ฌ์ ๋๊ธ์ ์ง๋ถํ๊ธฐ ์ ์ ๋ฐ๊ธ์ฌ๊ฐ ํ๋งค์์๊ฒ ๋๊ธ์ ๋จผ์ ์ง๋ถํฉ๋๋ค.
+- ๋ฐํ์ฌ๋ ๊ณ ๊ฐ ๊ณ์ข ๊ด๋ฆฌ, ๋ช
์ธ์ ์ ๊ณต, ์ฌ๊ธฐ ํ์ง, ์ํ ๊ด๋ฆฌ, ์ฒญ์ฐ ๋ฐ ๊ฒฐ์ ๋ฑ ๊ธฐํ ์ด์ ๋น์ฉ์ด ๋ฐ์ํฉ๋๋ค.
-### How does VISA work when we swipe a credit card at a merchantโs shop?
+### ์์ ์์ ์ฐ๋ฆฌ๊ฐ ์ ์ฉ์นด๋๋ฅผ ๊ธ์ ๋, VISA๋ ์ด๋ป๊ฒ ์๋ํ๋์?
-VISA, Mastercard, and American Express act as card networks for the clearing and settling of funds. The card acquiring bank and the card issuing bank can be โ and often are โ different. If banks were to settle transactions one by one without an intermediary, each bank would have to settle the transactions with all the other banks. This is quite inefficient.
+๋น์, ๋ง์คํฐ์นด๋, ์๋ฉ๋ฆฌ์นธ ์ต์คํ๋ ์ค๋ ์๊ธ ์ฒญ์ฐ ๋ฐ ์ ์ฐ์ ์ํ ์นด๋ ๋คํธ์ํฌ ์ญํ ์ ํฉ๋๋ค. ์นด๋ ๋งค์
์ํ๊ณผ ์นด๋ ๋ฐ๊ธ ์ํ์ ์๋ก ๋ค๋ฅผ ์ ์์ผ๋ฉฐ, ์ค์ ๋ก๋ ์ข
์ข
๋ค๋ฆ
๋๋ค. ์ํ์ด ์ค๊ฐ์ ์์ด ํ๋์ฉ ๊ฑฐ๋๋ฅผ ์ ์ฐํ๋ค๋ฉด, ๊ฐ ์ํ์ ๋ค๋ฅธ ๋ชจ๋ ์ํ๊ณผ ๊ฑฐ๋๋ฅผ ์ ์ฐํด์ผ ํฉ๋๋ค. ์ด๋ ๋งค์ฐ ๋นํจ์จ์ ์
๋๋ค.
-The diagram below shows VISAโs role in the credit card payment process. There are two flows involved. Authorization flow happens when the customer swipes the credit card. Capture and settlement flow happens when the merchant wants to get the money at the end of the day.
+์๋ ๋ค์ด์ด๊ทธ๋จ์ ์ ์ฉ ์นด๋ ๊ฒฐ์ ํ๋ก์ธ์ค์์ VISA์ ์ญํ ์ ๋ณด์ฌ์ค๋๋ค. ๋ ๊ฐ์ง ํ๋ก์ฐ๊ฐ ๊ด๋ จ๋์ด ์์ต๋๋ค. ์น์ธ ํ๋ฆ์ ๊ณ ๊ฐ์ด ์ ์ฉ์นด๋๋ฅผ ์ค์์ดํํ ๋ ๋ฐ์ํฉ๋๋ค. ์บก์ฒ์ ์ ์ฐ ํ๋ก์ฐ๋ ์์ ์ด ํ๋ฃจ๊ฐ ๋๋ ๋ ๋ฐ์ํฉ๋๋ค.
-- Authorization Flow
+- ๊ฑฐ๋ ์น์ธ ํ๋ก์ฐAuthorization Flow
-Step 0: The card issuing bank issues credit cards to its customers.
+0๋จ๊ณ: ์นด๋ ๋ฐ๊ธ ์ํ์ด ๊ณ ๊ฐ์๊ฒ ์ ์ฉ์นด๋๋ฅผ ๋ฐ๊ธํฉ๋๋ค.
-Step 1: The cardholder wants to buy a product and swipes the credit card at the Point of Sale (POS) terminal in the merchantโs shop.
+1๋จ๊ณ: ์นด๋ ์์ ์๊ฐ ์ ํ์ ๊ตฌ๋งคํ๊ธฐ ์ํด ์์ ์ POS(Point of Sale) ๋จ๋ง๊ธฐ์์ ์ ์ฉ์นด๋๋ฅผ ์ค์์ดํํฉ๋๋ค.
-Step 2: The POS terminal sends the transaction to the acquiring bank, which has provided the POS terminal.
+2๋จ๊ณ: POS ๋จ๋ง๊ธฐ๋ POS ๋จ๋ง๊ธฐ๋ฅผ ์ ๊ณตํ ๋งค์
์ํ์ผ๋ก ๊ฑฐ๋๋ฅผ ์ ์กํฉ๋๋ค.
-Steps 3 and 4: The acquiring bank sends the transaction to the card network, also called the card scheme. The card network sends the transaction to the issuing bank for approval.
+3, 4๋จ๊ณ: ๋งค์
์ํ์ ๊ฑฐ๋๋ฅผ ์นด๋ ๋คํธ์ํฌ๋ก ์ ์กํ๋ฉฐ, ์ด๋ฅผ ์นด๋ ์คํด์ด๋ผ๊ณ ๋ ํฉ๋๋ค. ์นด๋ ๋คํธ์ํฌ๋ ์น์ธ์ ์ํด ๋ฐ๊ธ ์ํ์ผ๋ก ๊ฑฐ๋๋ฅผ ์ ์กํฉ๋๋ค.
-Steps 4.1, 4.2 and 4.3: The issuing bank freezes the money if the transaction is approved. The approval or rejection is sent back to the acquirer, as well as the POS terminal.
+4.1, 4.2, 4.3๋จ๊ณ: ํธ๋์ญ์
์ด ์น์ธ๋๋ฉด ๋ฐํ ์ํ์ ์๊ธ์ ๋๊ฒฐํฉ๋๋ค. ์น์ธ ๋๋ ๊ฑฐ๋ถ๊ฐ ๋งค์
์ํ์๊ฒ ๋ค์ ์ ์ก๋๊ณ POS ๋จ๋ง๊ธฐ๋ก๋ ์ ์ก๋ฉ๋๋ค.
-- Capture and Settlement Flow
+- ์บก์ฒ์ ์ ์ฐ ํ๋ก์ฐCapture and Settlement Flow
-Steps 1 and 2: The merchant wants to collect the money at the end of the day, so they hit โcaptureโ on the POS terminal. The transactions are sent to the acquirer in batch. The acquirer sends the batch file with transactions to the card network.
+1, 2๋จ๊ณ: ํ๋งค์๋ ํ๋ฃจ๊ฐ ๋๋ ๋ ๋์ ๋ฐ์ผ๋ ค๊ณ POS ๋จ๋ง๊ธฐ์์ '๋งค์
'์ ๋๋ฆ
๋๋ค. ํธ๋์ญ์
์ ๋งค์
์ํ์๊ฒ ์ผ๊ด์ ์ผ๋ก ์ ์ก๋ฉ๋๋ค. ๋งค์
์ํ์ ํธ๋์ญ์
์ด ํฌํจ๋ ๋ฐฐ์น ํ์ผ์ ์นด๋ ๋คํธ์ํฌ๋ก ์ ์กํฉ๋๋ค.
-Step 3: The card network performs clearing for the transactions collected from different acquirers, and sends the clearing files to different issuing banks.
+3๋จ๊ณ: ์นด๋ ๋คํธ์ํฌ๋ ์ฌ๋ฌ ๋งค์
์ํ์ผ๋ก๋ถํฐ ์์งํ ๊ฑฐ๋์ ๋ํด ์ ์ฐ์ ์ํํ๊ณ ์ ์ฐ ํ์ผ์ ์ฌ๋ฌ ๋ฐ๊ธ ์ํ์ผ๋ก ์ ์กํฉ๋๋ค.
-Step 4: The issuing banks confirm the correctness of the clearing files, and transfer money to the relevant acquiring banks.
+4๋จ๊ณ: ๋ฐํ ์ํ์ ์ ์ฐ ํ์ผ์ ์ ํ์ฑ์ ํ์ธํ๊ณ ๊ด๋ จ ๋งค์
์ํ์ผ๋ก ์๊ธ์ ์ด์ฒดํฉ๋๋ค.
-Step 5: The acquiring bank then transfers money to the merchantโs bank.
+5๋จ๊ณ: ๊ทธ๋ฌ๋ฉด ๋งค์
์ํ์ด ํ๋งค์์ ์ํ์ผ๋ก ์ก๊ธํฉ๋๋ค.
-Step 4: The card network clears up the transactions from different acquiring banks. Clearing is a process in which mutual offset transactions are netted, so the number of total transactions is reduced.
+4๋จ๊ณ: ์นด๋ ๋คํธ์ํฌ๋ ์๋ก ๋ค๋ฅธ ์นด๋ ๋ฐ๊ธ ์ํ์ ๊ฑฐ๋๋ฅผ ์ ์ฐํฉ๋๋ค. ์ ์ฐ์ ์ํธ ์์ ๊ฑฐ๋๋ฅผ ๊ฒฐ์ฐํ๋ ๊ณผ์ ์ผ๋ก, ์ด ๊ฑฐ๋ ์๋ฅผ ์ค์
๋๋ค.
-In the process, the card network takes on the burden of talking to each bank and receives service fees in return.
+์ด ๊ณผ์ ์์ ์นด๋ ๋คํธ์ํฌ๋ ๊ฐ ์ํ๊ณผ ๋ํํด์ผ ํ๋ ๋ถ๋ด์ ๋ ์๊ณ ๊ทธ ๋๊ฐ๋ก ์๋น์ค ์์๋ฃ๋ฅผ ๋ฐ์ต๋๋ค.
-### Payment Systems Around The World Series (Part 1): Unified Payments Interface (UPI) in India
+### ์ธ๊ณ์ ๊ฒฐ์ ์์คํ
์๋ฆฌ์ฆ(1๋ถ): ์ธ๋์ ํตํฉ ๊ฒฐ์ ์ธํฐํ์ด์ค(UPI)
-Whatโs UPI? UPI is an instant real-time payment system developed by the National Payments Corporation of India.
+UPI๋ ๋ฌด์์ธ๊ฐ์? UPI๋ ์ธ๋ ๊ตญ๋ฆฝ๊ฒฐ์ ๊ณต์ฌ์์ ๊ฐ๋ฐํ ์ค์๊ฐ ์ฆ์ ๊ฒฐ์ ์์คํ
์
๋๋ค.
-It accounts for 60% of digital retail transactions in India today.
+ํ์ฌ ์ธ๋์์ ๋์งํธ ์๋งค ๊ฑฐ๋์ 60%๋ฅผ ์ฐจ์งํ๊ณ ์์ต๋๋ค.
-UPI = payment markup language + standard for interoperable payments
+UPI = ๊ฒฐ์ ๋งํฌ์
์ธ์ด + ์ํธ ์ด์ฉ ๊ฐ๋ฅํ ๊ฒฐ์ ํ์ค
From 13afa41f177e2d2f09a1fd33cb9f3c0031e66d22 Mon Sep 17 00:00:00 2001
From: kei kim
Date: Wed, 31 Jan 2024 15:25:45 +0900
Subject: [PATCH 09/16] docs: translate to DevOps
---
translations/README-kr.md | 91 +++++++++++++++++++--------------------
1 file changed, 45 insertions(+), 46 deletions(-)
diff --git a/translations/README-kr.md b/translations/README-kr.md
index 03b8f32..d6b8f78 100644
--- a/translations/README-kr.md
+++ b/translations/README-kr.md
@@ -70,9 +70,9 @@
- [์ธ๊ณ์ ๊ฒฐ์ ์์คํ
์๋ฆฌ์ฆ(1๋ถ): ์ธ๋์ ํตํฉ ๊ฒฐ์ ์ธํฐํ์ด์ค(UPI)](#์ธ๊ณ์-๊ฒฐ์ -์์คํ
-์๋ฆฌ์ฆ1๋ถ-์ธ๋์-ํตํฉ-๊ฒฐ์ -์ธํฐํ์ด์คupi)
- [DevOps](#devops)
- [DevOps vs. SRE vs. Platform Engineering. ๋ฌด์์ด ๋ค๋ฅธ๊ฐ์?](#devops-vs-sre-vs-platform-engineering-what-is-the-difference)
- - [k8s(Kubernetes)๋ ๋ฌด์์ธ๊ฐ์?](#what-is-k8s-kubernetes)
- - [Docker vs. Kubernetes. ์ด๋ค๊ฒ์ ์ฌ์ฉํด์ผ ํ๋์?](#docker-vs-kubernetes-which-one-should-we-use)
- - [Docker๋ ์ด๋ป๊ฒ ์๋ํ๋์?](#how-does-docker-work)
+ - [k8s(Kubernetes)๋ ๋ฌด์์ธ๊ฐ์?](#k8skubernetes๋-๋ฌด์์ธ๊ฐ์)
+ - [Docker vs. Kubernetes. ์ด๋ค๊ฒ์ ์ฌ์ฉํด์ผ ํ๋์?](#docker-vs-kubernetes-์ด๋ค๊ฒ์-์ฌ์ฉํด์ผ-ํ๋์)
+ - [Docker๋ ์ด๋ป๊ฒ ์๋ํ๋์?](#docker๋-์ด๋ป๊ฒ-์๋ํ๋์)
- [GIT](#git)
- [Git Commands ์๋ ๋ฐฉ์](#how-git-commands-work)
- [Git์ ์ด๋ป๊ฒ ์๋ํ๋์?](#how-does-git-work)
@@ -750,11 +750,11 @@ SQL ์ธ์ด์๋ 5๊ฐ์ง ๊ตฌ์ฑ ์์๊ฐ ์์ต๋๋ค.
-1. Redis๋ RAM ๊ธฐ๋ฐ ๋ฐ์ดํฐ ์ ์ฅ์์
๋๋ค. RAM ์ก์ธ์ค๋ ์์์ ๋์คํฌ ์ก์ธ์ค๋ณด๋ค ์ต์ 1000๋ฐฐ ์ด์ ๋น ๋ฆ
๋๋ค.
+1. Redis๋ RAM ๊ธฐ๋ฐ ๋ฐ์ดํฐ ์คํ ๋ฆฌ์ง์
๋๋ค. RAM ์ก์ธ์ค๋ ์์์ ๋์คํฌ ์ก์ธ์ค๋ณด๋ค ์ต์ 1000๋ฐฐ ์ด์ ๋น ๋ฆ
๋๋ค.
2. Redis๋ ์คํ ํจ์จ์ฑ์ ์ํด IO ๋ฉํฐํ๋ ์ฑ๊ณผ ์ฑ๊ธ ์ค๋ ๋ ์ต์คํ์
๋ฃจํ๋ฅผ ํ์ฉํฉ๋๋ค.
3. Redis๋ ๋ช ๊ฐ์ง ํจ์จ์ ์ธ ๋ก์ฐ ๋ ๋ฒจ ๋ฐ์ดํฐ ๊ตฌ์กฐ๋ฅผ ํ์ฉํฉ๋๋ค.
-์ง๋ฌธ: ๋ ๋ค๋ฅธ ์ธ๊ธฐ ์๋ ์ธ๋ฉ๋ชจ๋ฆฌ ์ ์ฅ์๋ Memcached์
๋๋ค. Redis์ Memcached์ ์ฐจ์ด์ ์ ์๊ณ ์๋์?
+์ง๋ฌธ: ๋ ๋ค๋ฅธ ์ธ๊ธฐ ์๋ ์ธ๋ฉ๋ชจ๋ฆฌ ์คํ ๋ฆฌ์ง๋ Memcached์
๋๋ค. Redis์ Memcached์ ์ฐจ์ด์ ์ ์๊ณ ์๋์?
์ด ๋ค์ด์ด๊ทธ๋จ์ ์คํ์ผ์ด ์ด์ ๊ฒ์๋ฌผ๊ณผ ๋ค๋ฅด๋ค๋ ๊ฒ์ ๋์น์ฑ์
จ์ ๊ฒ์
๋๋ค. ์ด๋ ์ชฝ์ ์ ํธํ์๋์ง ์๋ ค์ฃผ์ธ์.
@@ -888,7 +888,7 @@ Redis๋ ๋ค์ด์ด๊ทธ๋จ์ ํ์๋ ๊ฒ์ฒ๋ผ ๋ค์ํ ์๋๋ฆฌ์ค์์ ์ฌ
- ๋ง์ดํฌ๋ก์๋น์ค๋ ํด๋ผ์ฐ๋์ ๋ฐฐํฌ๋ฉ๋๋ค. AWS, Microsoft Azure, Google GCP ์ค์์ ์ ํํ ์ ์์ต๋๋ค.
Cache and Full-text Search - Redis๋ key-value ์์ ์บ์ฑํ๊ธฐ ์ํ ์ผ๋ฐ์ ์ธ ์ ํ์
๋๋ค. ํ ํ
์คํธ ์์น์๋ Elasticsearch๊ฐ ์ฌ์ฉ๋ฉ๋๋ค.
- Communications - ์๋น์ค๊ฐ ์๋ก ํต์ ํ๊ธฐ ์ํด์๋ ๋ฉ์์ง ์ธํ๋ผ๋ก Kafka ํน์ RPC๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค.
-- Persistence - ๊ด๊ณํ ๋ฐ์ดํฐ๋ฒ ์ด์ค์๋ MySQL ๋๋ PostgreSQL์ ์ฌ์ฉํ ์ ์์ผ๋ฉฐ, ๊ฐ์ฒด ์ ์ฅ์์๋ Amazon S3์ ์ฌ์ฉํ ์ ์์ต๋๋ค. ํ์ํ ๊ฒฝ์ฐ wide-column ์ ์ฅ์๋ก Cassandra๋ฅผ ์ฌ์ฉํ ์๋ ์์ต๋๋ค.
+- Persistence - ๊ด๊ณํ ๋ฐ์ดํฐ๋ฒ ์ด์ค์๋ MySQL ๋๋ PostgreSQL์ ์ฌ์ฉํ ์ ์์ผ๋ฉฐ, ๊ฐ์ฒด ์คํ ๋ฆฌ์ง์๋ Amazon S3์ ์ฌ์ฉํ ์ ์์ต๋๋ค. ํ์ํ ๊ฒฝ์ฐ wide-column ์คํ ๋ฆฌ์ง๋ก Cassandra๋ฅผ ์ฌ์ฉํ ์๋ ์์ต๋๋ค.
- Management & Monitoring - ์๋ง์ ๋ง์ดํฌ๋ก์๋น์ค๋ฅผ ๊ด๋ฆฌํ๊ธฐ ์ํ ์ผ๋ฐ์ ์ธ ์ด์ ๋๊ตฌ๋ก Prometheus, Elastic Stack, Kubernetes๊ฐ ์์ต๋๋ค.
### ์นดํ์นด๊ฐ ๋น ๋ฅธ ์ด์
@@ -1016,119 +1016,118 @@ UPI = ๊ฒฐ์ ๋งํฌ์
์ธ์ด + ์ํธ ์ด์ฉ ๊ฐ๋ฅํ ๊ฒฐ์ ํ์ค
### DevOps vs. SRE vs. Platform Engineering. What is the difference?
-The concepts of DevOps, SRE, and Platform Engineering have emerged at different times and have been developed by various individuals and organizations.
+๋ฐ๋ธ์ต์ค, SRE, ํ๋ซํผ ์์ง๋์ด๋ง์ ๊ฐ๋
์ ์๋ก ๋ค๋ฅธ ์๊ธฐ์ ๋ฑ์ฅํ์ฌ ๋ค์ํ ๊ฐ์ธ๊ณผ ์กฐ์ง์ ์ํด ๋ฐ์ ํด ์์ต๋๋ค.
-DevOps as a concept was introduced in 2009 by Patrick Debois and Andrew Shafer at the Agile conference. They sought to bridge the gap between software development and operations by promoting a collaborative culture and shared responsibility for the entire software development lifecycle.
+๋ฐ๋ธ์ต์ค๋ผ๋ ๊ฐ๋
์ 2009๋
์ ์์ผ ์ปจํผ๋ฐ์ค์์ Patrick Debois์ Andrew Shafer์ ์ํด ์๊ฐ๋์์ต๋๋ค. ์ด๋ค์ ์ ์ฒด ์ํํธ์จ์ด ๊ฐ๋ฐ ๋ผ์ดํ์ฌ์ดํด์ ๋ํ ๊ณต๋ ์ฑ
์๊ณผ ํ์
๋ฌธํ๋ฅผ ์ฅ๋ คํจ์ผ๋ก์จ ์ํํธ์จ์ด ๊ฐ๋ฐ๊ณผ ์ด์ ๊ฐ์ ๊ฐ๊ทน์ ์ขํ๊ณ ์ ํ์ต๋๋ค.
-SRE, or Site Reliability Engineering, was pioneered by Google in the early 2000s to address operational challenges in managing large-scale, complex systems. Google developed SRE practices and tools, such as the Borg cluster management system and the Monarch monitoring system, to improve the reliability and efficiency of their services.
+SRE(Site Reliability Engineering)๋ 2000๋
๋ ์ด๋ฐ ๊ตฌ๊ธ์์ ๋๊ท๋ชจ ๋ณต์กํ ์์คํ
๊ด๋ฆฌ์ ์ด์์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด ๊ฐ์ฒ๋์์ต๋๋ค. ๊ตฌ๊ธ์ ์๋น์ค์ ์์ ์ฑ๊ณผ ํจ์จ์ฑ์ ๋์ด๊ธฐ ์ํด Borg ํด๋ฌ์คํฐ ๊ด๋ฆฌ ์์คํ
, Monarch ๋ชจ๋ํฐ๋ง ์์คํ
๊ณผ ๊ฐ์ SRE ์ค์ต ๋ฐ ๋๊ตฌ๋ฅผ ๊ฐ๋ฐํ์ต๋๋ค.
-Platform Engineering is a more recent concept, building on the foundation of SRE engineering. The precise origins of Platform Engineering are less clear, but it is generally understood to be an extension of the DevOps and SRE practices, with a focus on delivering a comprehensive platform for product development that supports the entire business perspective.
+ํ๋ซํผ ์์ง๋์ด๋ง์ SRE ์์ง๋์ด๋ง์ ๊ธฐ๋ฐ์ผ๋ก ํ ์ต๊ทผ ๊ฐ๋
์
๋๋ค. ํ๋ซํผ ์์ง๋์ด๋ง์ ์ ํํ ๊ธฐ์์ ๋ช
ํํ์ง ์์ง๋ง, ์ผ๋ฐ์ ์ผ๋ก ์ ํ ๊ฐ๋ฐ์ ์ํ ํฌ๊ด์ ์ธ ํ๋ซํผ์ ์ ๊ณตํ๊ณ ์ ์ฒด ์ฌ์
๊ด์ ์ ์ง์ํ๋ ๋ฐ ์ด์ ์ ๋ DevOps์ SRE ๊ดํ์ ํ์ฅ์ผ๋ก ์ดํด๋ฉ๋๋ค.
-It's worth noting that while these concepts emerged at different times. They are all related to the broader trend of improving collaboration, automation, and efficiency in software development and operations.
+์ด๋ฌํ ๊ฐ๋
์ด ์๋ก ๋ค๋ฅธ ์๊ธฐ์ ๋ฑ์ฅํ๋ค๋ ์ ์ ์ฃผ๋ชฉํ ํ์๊ฐ ์์ต๋๋ค. ์ด ๊ฐ๋
๋ค์ ๋ชจ๋ ์ํํธ์จ์ด ๊ฐ๋ฐ ๋ฐ ์ด์ ์ ๋ฐ์ ๊ฑธ์ณ ์ง์์ ์ธ ํ์
, ์๋ํ, ํจ์จ์ฑ ๊ฐ์ ์ด๋ผ๋ ๊ณตํต ๋ชฉํ๋ฅผ ๋ฐํ์ผ๋ก ํฉ๋๋ค.
-### What is k8s (Kubernetes)?
+### k8s(Kubernetes)๋ ๋ฌด์์ธ๊ฐ์?
-K8s is a container orchestration system. It is used for container deployment and management. Its design is greatly impacted by Googleโs internal system Borg.
+K8s๋ ์ปจํ
์ด๋ ์ค์ผ์คํธ๋ ์ด์
์์คํ
์
๋๋ค. ์ปจํ
์ด๋ ๋ฐฐํฌ ๋ฐ ๊ด๋ฆฌ์ ์ฌ์ฉ๋ฉ๋๋ค. ์ด ์์คํ
์ ์ค๊ณ๋ Google์ ๋ด๋ถ ์์คํ
์ธ Borg์ ์ํฅ์ ๋ง์ด ๋ฐ์์ต๋๋ค.
-A k8s cluster consists of a set of worker machines, called nodes, that run containerized applications. Every cluster has at least one worker node.
+k8s ํด๋ฌ์คํฐ๋ ์ปจํ
์ด๋ํ๋ ์ ํ๋ฆฌ์ผ์ด์
์ ์คํํ๋ ๋
ธ๋๋ผ๊ณ ํ๋ ์ผ๋ จ์ ์์ปค ๋จธ์ ์ผ๋ก ๊ตฌ์ฑ๋ฉ๋๋ค. ๋ชจ๋ ํด๋ฌ์คํฐ์๋ ํ๋ ์ด์์ ์์ปค ๋
ธ๋๊ฐ ์์ต๋๋ค.
-The worker node(s) host the Pods that are the components of the application workload. The control plane manages the worker nodes and the Pods in the cluster. In production environments, the control plane usually runs across multiple computers, and a cluster usually runs multiple nodes, providing fault tolerance and high availability.
+์์ปค ๋
ธ๋๋ ์ ํ๋ฆฌ์ผ์ด์
์ํฌ๋ก๋์ ์ปดํฌ๋ํธ์ธ ํ๋๋ฅผ ํธ์คํ
ํฉ๋๋ค. ์ปจํธ๋กค ํ๋ ์ธ์ ํด๋ฌ์คํฐ์ ์์ปค ๋
ธ๋์ ํ๋๋ฅผ ๊ด๋ฆฌํฉ๋๋ค. ํ๋ก๋์
ํ๊ฒฝ์์ ์ปจํธ๋กค ํ๋ ์ธ์ ์ผ๋ฐ์ ์ผ๋ก ์ฌ๋ฌ ๋์ ์ปดํจํฐ์์ ์คํ๋๋ฉฐ, ํด๋ฌ์คํฐ๋ ์ผ๋ฐ์ ์ผ๋ก ์ฌ๋ฌ ๋
ธ๋๋ฅผ ์คํํ์ฌ ๋ด๊ฒฐํจ์ฑ(tolerance)๊ณผ ๊ณ ๊ฐ์ฉ์ฑ์ ์ ๊ณตํฉ๋๋ค.
-- Control Plane Components
+- Control Plane ์ปดํฌ๋ํธ
1. API Server
- The API server talks to all the components in the k8s cluster. All the operations on pods are executed by talking to the API server.
+ API ์๋ฒ๋ k8s ํด๋ฌ์คํฐ์ ๋ชจ๋ ์ปดํฌ๋ํธ์ ํต์ ํฉ๋๋ค. ํ๋์ ๋ํ ๋ชจ๋ ์์
์ API ์๋ฒ์ ํต์ ํ์ฌ ์คํ๋ฉ๋๋ค.
2. Scheduler
- The scheduler watches pod workloads and assigns loads on newly created pods.
+ ์ค์ผ์ค๋ฌ๋ ํ๋ ์ํฌ๋ก๋๋ฅผ ๊ฐ์ํ๊ณ ์๋ก ์์ฑ๋ ํ๋์ ๋ก๋๋ฅผ ํ ๋นํฉ๋๋ค.
3. Controller Manager
- The controller manager runs the controllers, including Node Controller, Job Controller, EndpointSlice Controller, and ServiceAccount Controller.
+ ์ปจํธ๋กค๋ฌ ๋งค๋์ ๋ ๋
ธ๋ ์ปจํธ๋กค๋ฌ, ์ก ์ปจํธ๋กค๋ฌ, ์๋ํฌ์ธํธ์ฌ๋ผ์ด์ค ์ปจํธ๋กค๋ฌ, ์๋น์ค ์ด์นด์ดํธ ์ปจํธ๋กค๋ฌ๋ฅผ ํฌํจํ ์ปจํธ๋กค๋ฌ๋ฅผ ์คํํฉ๋๋ค.
4. Etcd
- etcd is a key-value store used as Kubernetes' backing store for all cluster data.
+ etcd๋ ๋ชจ๋ ํด๋ฌ์คํฐ ๋ฐ์ดํฐ์ ๋ํ ์ฟ ๋ฒ๋คํฐ์ค์ ๋ฐฑ์
์คํ ๋ฆฌ์ง๋ก ์ฌ์ฉ๋๋ ํค-๋ฐธ๋ฅ ์คํ ๋ฆฌ์ง์
๋๋ค.
- Nodes
1. Pods
- A pod is a group of containers and is the smallest unit that k8s administers. Pods have a single IP address applied to every container within the pod.
+ ํ๋๋ ์ปจํ
์ด๋ ๊ทธ๋ฃน์ผ๋ก, k8์ด ๊ด๋ฆฌํ๋ ๊ฐ์ฅ ์์ ๋จ์์
๋๋ค. ํ๋์๋ ํ๋ ๋ด์ ๋ชจ๋ ์ปจํ
์ด๋์ ๋จ์ผ IP ์ฃผ์๊ฐ ์ ์ฉ๋ฉ๋๋ค.
2. Kubelet
- An agent that runs on each node in the cluster. It ensures containers are running in a Pod.
+ ํด๋ฌ์คํฐ์ ๊ฐ ๋
ธ๋์์ ์คํ๋๋ ์์ด์ ํธ. ์ปจํ
์ด๋๊ฐ ํ๋์์ ์คํ๋๋๋ก ๋ณด์ฅํฉ๋๋ค.
3. Kube Proxy
- Kube-proxy is a network proxy that runs on each node in your cluster. It routes traffic coming into a node from the service. It forwards requests for work to the correct containers.
+ Kube-proxy๋ ํด๋ฌ์คํฐ์ ๊ฐ ๋
ธ๋์์ ์คํ๋๋ ๋คํธ์ํฌ ํ๋ก์์
๋๋ค. ์๋น์ค์์ ๋
ธ๋๋ก ๋ค์ด์ค๋ ํธ๋ํฝ์ ๋ผ์ฐํ
ํฉ๋๋ค. ์์
์์ฒญ์ ์ฌ๋ฐ๋ฅธ ์ปจํ
์ด๋๋ก ์ ๋ฌํฉ๋๋ค.
-### Docker vs. Kubernetes. Which one should we use?
+### Docker vs. Kubernetes. ์ด๋ค๊ฒ์ ์ฌ์ฉํด์ผ ํ๋์?
-What is Docker ?
+๋์ปคDocker๋ ๋ฌด์์ธ๊ฐ์?
-Docker is an open-source platform that allows you to package, distribute, and run applications in isolated containers. It focuses on containerization, providing lightweight environments that encapsulate applications and their dependencies.
+Docker๋ ๊ฒฉ๋ฆฌ๋ ์ปจํ
์ด๋์์ ์ ํ๋ฆฌ์ผ์ด์
์ ํจํค์ง, ๋ฐฐํฌ ๋ฐ ์คํํ ์ ์๋ ์คํ ์์ค ํ๋ซํผ์
๋๋ค. ์ปจํ
์ด๋ํ์ ์ค์ ์ ๋์ด ์ ํ๋ฆฌ์ผ์ด์
๊ณผ ๊ทธ ์ข
์์ฑ์ ์บก์ํํ๋ ๊ฒฝ๋ ํ๊ฒฝ์ ์ ๊ณตํฉ๋๋ค.
-What is Kubernetes ?
+Kubernetes๋ ๋ฌด์์ธ๊ฐ์?
-Kubernetes, often referred to as K8s, is an open-source container orchestration platform. It provides a framework for automating the deployment, scaling, and management of containerized applications across a cluster of nodes.
+K8s๋ผ๊ณ ๋ ๋ถ๋ฆฌ๋ Kubernetes๋ ์คํ ์์ค ์ปจํ
์ด๋ ์ค์ผ์คํธ๋ ์ด์
ํ๋ซํผ์
๋๋ค. ๋
ธ๋ ํด๋ฌ์คํฐ ์ ๋ฐ์์ ์ปจํ
์ด๋ํ๋ ์ ํ๋ฆฌ์ผ์ด์
์ ๋ฐฐํฌ, ์ค์ผ์ผ๋ง, ๊ด๋ฆฌ๋ฅผ ์๋ํํ๊ธฐ ์ํ ํ๋ ์์ํฌ๋ฅผ ์ ๊ณตํฉ๋๋ค.
-How are both different from each other ?
+๋ ๊ฐ์ง๊ฐ ์๋ก ์ด๋ป๊ฒ ๋ค๋ฅธ๊ฐ์?
-Docker: Docker operates at the individual container level on a single operating system host.
+Docker: ๋์ปค๋ ๋จ์ผ ์ด์ ์ฒด์ ํธ์คํธ์ ๊ฐ๋ณ ์ปจํ
์ด๋ ์์ค์์ ์๋ํฉ๋๋ค.
-You must manually manage each host and setting up networks, security policies, and storage for multiple related containers can be complex.
+๊ฐ ํธ์คํธ๋ฅผ ์๋์ผ๋ก ๊ด๋ฆฌํด์ผ ํ๋ฉฐ ์ฌ๋ฌ ๊ด๋ จ ์ปจํ
์ด๋์ ๋ํ ๋คํธ์ํฌ, ๋ณด์ ์ ์ฑ
, ์คํ ๋ฆฌ์ง๋ฅผ ์ค์ ํ๋ ๊ฒ์ ๋ณต์กํ ์ ์์ต๋๋ค.
-Kubernetes: Kubernetes operates at the cluster level. It manages multiple containerized applications across multiple hosts, providing automation for tasks like load balancing, scaling, and ensuring the desired state of applications.
+Kubernetes: ์ฟ ๋ฒ๋คํฐ์ค๋ ํด๋ฌ์คํฐ ๋ ๋ฒจ์์ ์๋ํฉ๋๋ค. ์ฌ๋ฌ ํธ์คํธ์ ๊ฑธ์ณ ์ฌ๋ฌ ์ปจํ
์ด๋ํ๋ ์ ํ๋ฆฌ์ผ์ด์
์ ๊ด๋ฆฌํ๋ฉฐ, ๋ก๋ ๋ฐธ๋ฐ์ฑ, ์ค์ผ์ผ๋ง, ์ ํ๋ฆฌ์ผ์ด์
์ ์ํ๋ ์ํ ๋ณด์ฅ๊ณผ ๊ฐ์ ์์
์ ๋ํ ์๋ํ๋ฅผ ์ ๊ณตํฉ๋๋ค.
-In short, Docker focuses on containerization and running containers on individual hosts, while Kubernetes specializes in managing and orchestrating containers at scale across a cluster of hosts.
+๊ฐ๋จํ ๋งํด, ๋์ปค๋ ์ปจํ
์ด๋ํ ๋ฐ ๊ฐ๋ณ ํธ์คํธ์์ ์ปจํ
์ด๋๋ฅผ ์คํํ๋ ๋ฐ ์ค์ ์ ๋๋ ๋ฐ๋ฉด, ์ฟ ๋ฒ๋คํฐ์ค๋ ํธ์คํธ ํด๋ฌ์คํฐ ์ ์ฒด์์ ์ปจํ
์ด๋๋ฅผ ๋๊ท๋ชจ๋ก ๊ด๋ฆฌํ๊ณ ์กฐ์ ํ๋ ๋ฐ ํนํ๋์ด ์์ต๋๋ค.
-### How does Docker work?
+### Docker๋ ์ด๋ป๊ฒ ์๋ํ๋์?
-The diagram below shows the architecture of Docker and how it works when we run โdocker buildโ, โdocker pullโ
-and โdocker runโ.
+์๋ ๋ค์ด์ด๊ทธ๋จ์ ๋์ปค์ ์ํคํ
์ฒ์ "docker build", "docker pull", "docker run" ์ ์คํํ ๋ ์ด๋ป๊ฒ ์๋ํ๋์ง ๋ณด์ฌ์ค๋๋ค.
-There are 3 components in Docker architecture:
+๋์ปค ์ํคํ
์ฒ์๋ 3๊ฐ์ง ์ปดํฌ๋ํธ๊ฐ ์์ต๋๋ค.
- Docker client
- The docker client talks to the Docker daemon.
+ ๋์ปค ํด๋ผ์ด์ธํธ๊ฐ ๋์ปค ๋ฐ๋ชฌ๊ณผ ํต์ ํฉ๋๋ค.
- Docker host
- The Docker daemon listens for Docker API requests and manages Docker objects such as images, containers, networks, and volumes.
+ ๋์ปค ๋ฐ๋ชฌ์ ๋์ปค API ์์ฒญ์ ์์ ํ๊ณ ์ด๋ฏธ์ง, ์ปจํ
์ด๋, ๋คํธ์ํฌ, ๋ณผ๋ฅจ ๊ฐ์ ๋์ปค ๊ฐ์ฒด๋ฅผ ๊ด๋ฆฌํฉ๋๋ค.
- Docker registry
- A Docker registry stores Docker images. Docker Hub is a public registry that anyone can use.
+ ๋์ปค ๋ ์ง์คํธ๋ฆฌ๋ ๋์ปค ์ด๋ฏธ์ง๋ฅผ ์ ์ฅํฉ๋๋ค. ๋์ปค Hub๋ ๋๊ตฌ๋ ์ฌ์ฉํ ์ ์๋ ๊ณต์ฉ ๋ ์ง์คํธ๋ฆฌ์
๋๋ค.
-Letโs take the โdocker runโ command as an example.
+"docker run" ์ปค๋งจ๋๋ฅผ ์๋ก ๋ค์ด ๋ณด๊ฒ ์ต๋๋ค.
- 1. Docker pulls the image from the registry.
- 1. Docker creates a new container.
- 1. Docker allocates a read-write filesystem to the container.
- 1. Docker creates a network interface to connect the container to the default network.
- 1. Docker starts the container.
+ 1. ๋์ปค๋ ๋ ์ง์คํธ๋ฆฌ์์ ์ด๋ฏธ์ง๋ฅผ ๊ฐ์ ธ์ต๋๋ค.
+ 1. ๋์ปค๊ฐ ์ ์ปจํ
์ด๋๋ฅผ ์์ฑํฉ๋๋ค.
+ 1. ๋์ปค๋ ์ปจํ
์ด๋์ ์ฝ๊ธฐ-์ฐ๊ธฐ ํ์ผ์์คํ
์ ํ ๋นํฉ๋๋ค.
+ 1. ๋์ปค๋ ์ปจํ
์ด๋๋ฅผ ๋ํดํธ ๋คํธ์ํฌ์ ์ฐ๊ฒฐํ๊ธฐ ์ํด ๋คํธ์ํฌ ์ธํฐํ์ด์ค๋ฅผ ์์ฑํฉ๋๋ค.
+ 1. ๋์ปค๊ฐ ์ปจํ
์ด๋๋ฅผ ์์ํฉ๋๋ค.
## GIT
From 3f7058bf5327978746f81e7ef3498c896a1d92fc Mon Sep 17 00:00:00 2001
From: kei kim
Date: Wed, 31 Jan 2024 15:47:47 +0900
Subject: [PATCH 10/16] docs: translate to Git
---
translations/README-kr.md | 46 +++++++++++++++++++--------------------
1 file changed, 23 insertions(+), 23 deletions(-)
diff --git a/translations/README-kr.md b/translations/README-kr.md
index d6b8f78..0d9d57a 100644
--- a/translations/README-kr.md
+++ b/translations/README-kr.md
@@ -74,8 +74,8 @@
- [Docker vs. Kubernetes. ์ด๋ค๊ฒ์ ์ฌ์ฉํด์ผ ํ๋์?](#docker-vs-kubernetes-์ด๋ค๊ฒ์-์ฌ์ฉํด์ผ-ํ๋์)
- [Docker๋ ์ด๋ป๊ฒ ์๋ํ๋์?](#docker๋-์ด๋ป๊ฒ-์๋ํ๋์)
- [GIT](#git)
- - [Git Commands ์๋ ๋ฐฉ์](#how-git-commands-work)
- - [Git์ ์ด๋ป๊ฒ ์๋ํ๋์?](#how-does-git-work)
+ - [Git Commands ์๋ ๋ฐฉ์](#git-commands-์๋-๋ฐฉ์)
+ - [Git์ ์ด๋ป๊ฒ ์๋ํ๋์?](#git์-์ด๋ป๊ฒ-์๋ํ๋์)
- [Git merge vs. Git rebase](#git-merge-vs-git-rebase)
- [ํด๋ผ์ฐ๋ ์๋น์ค](#cloud-services)
- [๋ค์ํ ํด๋ผ์ฐ๋ ์๋น์ค์ ๋ํ ์ ์ฉํ ์นํธ์ํธ(2023๋
ํ)](#a-nice-cheat-sheet-of-different-cloud-services-2023-edition)
@@ -1131,67 +1131,67 @@ Kubernetes: ์ฟ ๋ฒ๋คํฐ์ค๋ ํด๋ฌ์คํฐ ๋ ๋ฒจ์์ ์๋ํฉ๋๋ค. ์ฌ๋ฌ
## GIT
-### How Git Commands work
+### Git Commands ์๋ ๋ฐฉ์
-To begin with, it's essential to identify where our code is stored. The common assumption is that there are only two locations - one on a remote server like Github and the other on our local machine. However, this isn't entirely accurate. Git maintains three local storages on our machine, which means that our code can be found in four places:
+์ฐ์ ์ฝ๋๊ฐ ์ด๋์ ์ ์ฅ๋์ด ์๋์ง ํ์
ํ๋ ๊ฒ์ด ์ค์ํฉ๋๋ค. ์ผ๋ฐ์ ์ผ๋ก ์ฝ๋๊ฐ ์ ์ฅ๋๋ ์์น๋ Github๊ณผ ๊ฐ์ ๋ฆฌ๋ชจํธ ์๋ฒ์ ๋ก์ปฌ ์ปดํจํฐ ๋ ๊ณณ๋ฟ์ด๋ผ๊ณ ๊ฐ์ ํฉ๋๋ค. ํ์ง๋ง ์ด๋ ์ ํํ์ง ์์ต๋๋ค. Git์ ์ปดํจํฐ์ 3๊ฐ์ ๋ก์ปฌ ์ ์ฅ์๋ฅผ ์ ์งํ๋ฏ๋ก ์ฝ๋๊ฐ ๋ค ๊ณณ์์ ๋ฐ๊ฒฌ๋ ์ ์์ต๋๋ค.
-- Working directory: where we edit files
-- Staging area: a temporary location where files are kept for the next commit
-- Local repository: contains the code that has been committed
-- Remote repository: the remote server that stores the code
+- Working directory: ํ์ผ์ ํธ์งํ๋ ์์น
+- Staging area: ๋ค์ ์ปค๋ฐ์ ์ํด ํ์ผ์ด ์ ์ฅ๋๋ ์์ ์์น
+- Local repository: ์ปค๋ฐ๋ ์ฝ๋๊ฐ ํฌํจ๋๋ ๋ก์ปฌ ์ ์ฅ์
+- Remote repository: ์ฝ๋๋ฅผ ์ ์ฅํ๋ ๋ฆฌ๋ชจํธ ์๋ฒ
-Most Git commands primarily move files between these four locations.
+๋๋ถ๋ถ์ Git ๋ช
๋ น์ ์ฃผ๋ก ์ด ๋ค ์์น ์ฌ์ด์์ ํ์ผ์ ์ด๋ํฉ๋๋ค.
-### How does Git Work?
+### Git์ ์ด๋ป๊ฒ ์๋ํ๋์?
-The diagram below shows the Git workflow.
+์๋ ๋ค์ด์ด๊ทธ๋จ์ Git ์ํฌํ๋ก์ฐ๋ฅผ ๋ณด์ฌ์ค๋๋ค.
-Git is a distributed version control system.
+Git์ ๋ถ์ฐ ๋ฒ์ ๊ด๋ฆฌ ์์คํ
์
๋๋ค.
-Every developer maintains a local copy of the main repository and edits and commits to the local copy.
+๋ชจ๋ ๊ฐ๋ฐ์๋ ๋ฉ์ธ ๋ฆฌํฌ์งํ ๋ฆฌ์ ๋ก์ปฌ ๋ณต์ฌ๋ณธ์ ์ ์ง ๊ด๋ฆฌํ๊ณ ๋ก์ปฌ ๋ณต์ฌ๋ณธ์์ ํธ์ง ๋ฐ ์ปค๋ฐํฉ๋๋ค.
-The commit is very fast because the operation doesnโt interact with the remote repository.
+์์
์ด ๋ฆฌ๋ชจํธ ๋ฆฌํฌ์งํ ๋ฆฌ์ ์ํธ์์ฉํ์ง ์๊ธฐ ๋๋ฌธ์ ์ปค๋ฐ์ด ๋งค์ฐ ๋น ๋ฆ
๋๋ค.
-If the remote repository crashes, the files can be recovered from the local repositories.
+๋ฆฌ๋ชจํธ ๋ฆฌํฌ์งํ ๋ฆฌ์ ์ถฉ๋์ด ๋ฐ์ํ๋ฉด ๋ก์ปฌ ๋ฆฌํฌ์งํ ๋ฆฌ์์ ํ์ผ์ ๋ณต๊ตฌํ ์ ์์ต๋๋ค.
### Git merge vs. Git rebase
-What are the differences?
+์ด๋ค ์ ์ด ๋ค๋ฅธ๊ฐ์?
-When we **merge changes** from one Git branch to another, we can use โgit mergeโ or โgit rebaseโ. The diagram below shows how the two commands work.
+ํ Git ๋ธ๋์น์์ ๋ค๋ฅธ ๋ธ๋์น๋ก **merge changes** ํ ๋ 'git merge' ๋๋ 'git rebase'๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค. ์๋ ๋ค์ด์ด๊ทธ๋จ์ ๋ ์ปค๋งจ๋์ ์๋ ๋ฐฉ์์ ๋ณด์ฌ์ค๋๋ค.
**Git merge**
-This creates a new commit Gโ in the main branch. Gโ ties the histories of both main and feature branches.
+๊ทธ๋ฌ๋ฉด ๋ฉ์ธ ๋ธ๋์น์ ์ ์ปค๋ฐ G'๊ฐ ๋ง๋ค์ด์ง๋๋ค. G'๋ ๋ฉ์ธ ๋ธ๋์น์ ํผ์ฒ ๋ธ๋์น์ ํ์คํ ๋ฆฌ๋ฅผ ๋ชจ๋ ์ฐ๊ฒฐํฉ๋๋ค.
-Git merge is **non-destructive**. Neither the main nor the feature branch is changed.
+Git ๋ณํฉ์ **non-destructive**์ด๋ค. ๋ฉ์ธ ๋ธ๋์น๋ ํผ์ฒ ๋ธ๋์น ๋ชจ๋ ๋ณ๊ฒฝ๋์ง ์๋๋ค.
**Git rebase**
-Git rebase moves the feature branch histories to the head of the main branch. It creates new commits Eโ, Fโ, and Gโ for each commit in the feature branch.
+Git ๋ฆฌ๋ฒ ์ด์ค๋ ํผ์ฒ ๋ธ๋์น ํ์คํ ๋ฆฌ๋ฅผ ๋ฉ์ธ ๋ธ๋์น์ ํค๋๋ก ๊ฐ์ ธ์ต๋๋ค. ๊ทธ๋ฌ๋ฉด ํผ์ฒ ๋ธ๋์น์ ๊ฐ ์ปค๋ฐ์ ๋ํด ์ ์ปค๋ฐ E', F', G' ๊ฐ ์์ฑ๋ฉ๋๋ค.
-The benefit of rebase is that it has a linear **commit history**.
+๋ฆฌ๋ฒ ์ด์ค์ ์ฅ์ ์ ์ ํ์ ์ธ **commit history**๊ฐ ์๋ค๋ ๊ฒ์
๋๋ค.
-Rebase can be dangerous if โthe golden rule of git rebaseโ is not followed.
+"git ๋ฆฌ๋ฒ ์ด์ค์ ํฉ๊ธ๋ฅ "์ ๋ฐ๋ฅด์ง ์์ผ๋ฉด ๋ฆฌ๋ฒ ์ด์ค๊ฐ ์ํํ ์ ์์ต๋๋ค.
**The Golden Rule of Git Rebase**
-Never use it on public branches!
+ํผ๋ธ๋ ๋ธ๋์น์์๋ ์ ๋ ์ฌ์ฉํ์ง ๋ง์ธ์!
## Cloud Services
From d7b1bfdc315a60fb51ab64a80b1fc64df46c41ba Mon Sep 17 00:00:00 2001
From: kei kim
Date: Wed, 31 Jan 2024 16:30:04 +0900
Subject: [PATCH 11/16] docs: translate to linux
---
translations/README-kr.md | 113 +++++++++++++++++++-------------------
1 file changed, 57 insertions(+), 56 deletions(-)
diff --git a/translations/README-kr.md b/translations/README-kr.md
index 0d9d57a..899aba3 100644
--- a/translations/README-kr.md
+++ b/translations/README-kr.md
@@ -77,15 +77,15 @@
- [Git Commands ์๋ ๋ฐฉ์](#git-commands-์๋-๋ฐฉ์)
- [Git์ ์ด๋ป๊ฒ ์๋ํ๋์?](#git์-์ด๋ป๊ฒ-์๋ํ๋์)
- [Git merge vs. Git rebase](#git-merge-vs-git-rebase)
-- [ํด๋ผ์ฐ๋ ์๋น์ค](#cloud-services)
- - [๋ค์ํ ํด๋ผ์ฐ๋ ์๋น์ค์ ๋ํ ์ ์ฉํ ์นํธ์ํธ(2023๋
ํ)](#a-nice-cheat-sheet-of-different-cloud-services-2023-edition)
- - [cloud native๋ ๋ฌด์์ธ๊ฐ์?](#what-is-cloud-native)
-- [Developer productivity tools](#developer-productivity-tools)
- - [JSON ํ์ผ ์๊ฐํ](#visualize-json-files)
- - [์ฝ๋๋ฅผ ์ํคํ
์ฒ ๋ค์ด์ด๊ทธ๋จ์ผ๋ก ์๋ ๋ณํ](#automatically-turn-code-into-architecture-diagrams)
-- [๋ฆฌ๋
์ค](#linux)
- - [๋ฆฌ๋
์ค ํ์ผ ์์คํ
์ค๋ช
](#linux-file-system-explained)
- - [๊ฐ์ฅ ๋ง์ด ์ฌ์ฉ๋๋ 18๊ฐ์ง ๋ฆฌ๋
์ค ๋ช
๋ น์ด ์์๋ณด๊ธฐ](#18-most-used-linux-commands-you-should-know)
+- [ํด๋ผ์ฐ๋ ์๋น์ค](#ํด๋ผ์ฐ๋-์๋น์ค)
+ - [๋ค์ํ ํด๋ผ์ฐ๋ ์๋น์ค์ ๋ํ ์ ์ฉํ ์นํธ์ํธ(2023๋
ํ)](#๋ค์ํ-ํด๋ผ์ฐ๋-์๋น์ค์-๋ํ-์ ์ฉํ-์นํธ์ํธ2023๋
ํ)
+ - [cloud native๋ ๋ฌด์์ธ๊ฐ์?](#cloud-native๋-๋ฌด์์ธ๊ฐ์)
+- [๊ฐ๋ฐ์ ์์ฐ์ฑ ๋๊ตฌ](#๊ฐ๋ฐ์-์์ฐ์ฑ-๋๊ตฌ)
+ - [JSON ํ์ผ ์๊ฐํ](#json-ํ์ผ-์๊ฐํ)
+ - [์ฝ๋๋ฅผ ์ํคํ
์ฒ ๋ค์ด์ด๊ทธ๋จ์ผ๋ก ์๋ ๋ณํ](#์ฝ๋๋ฅผ-์ํคํ
์ฒ-๋ค์ด์ด๊ทธ๋จ์ผ๋ก-์๋-๋ณํ)
+- [๋ฆฌ๋
์ค](#๋ฆฌ๋
์ค)
+ - [๋ฆฌ๋
์ค ํ์ผ ์์คํ
์ค๋ช
](#๋ฆฌ๋
์ค-ํ์ผ-์์คํ
-์ค๋ช
)
+ - [๊ฐ์ฅ ๋ง์ด ์ฌ์ฉ๋๋ 18๊ฐ์ง ๋ฆฌ๋
์ค ์ปค๋งจ๋ ์์๋ณด๊ธฐ](#๊ฐ์ฅ-๋ง์ด-์ฌ์ฉ๋๋-18๊ฐ์ง-๋ฆฌ๋
์ค-์ปค๋งจ๋-์์๋ณด๊ธฐ)
- [๋ณด์](#security)
- [HTTPS๋ ์ด๋ป๊ฒ ์๋ํ๋์?](#how-does-https-work)
- [๊ฐ๋จํ ์ฉ์ด๋ก ์ค๋ช
ํ๋ Oauth 2.0](#oauth-20-explained-with-simple-terms)
@@ -1193,118 +1193,119 @@ Git ๋ฆฌ๋ฒ ์ด์ค๋ ํผ์ฒ ๋ธ๋์น ํ์คํ ๋ฆฌ๋ฅผ ๋ฉ์ธ ๋ธ๋์น์ ํค๋
ํผ๋ธ๋ ๋ธ๋์น์์๋ ์ ๋ ์ฌ์ฉํ์ง ๋ง์ธ์!
-## Cloud Services
+## ํด๋ผ์ฐ๋ ์๋น์ค
-### A nice cheat sheet of different cloud services (2023 edition)
+### ๋ค์ํ ํด๋ผ์ฐ๋ ์๋น์ค์ ๋ํ ์ ์ฉํ ์นํธ์ํธ(2023๋
ํ)
-### What is cloud native?
+### cloud native๋ ๋ฌด์์ธ๊ฐ์?
-Below is a diagram showing the evolution of architecture and processes since the 1980s.
+์๋ ๋ค์ด์ด๊ทธ๋จ์ 1980๋
๋ ์ดํ ์ํคํ
์ฒ์ ํ๋ก์ธ์ค์ ์งํ๋ฅผ ๋ณด์ฌ์ค๋๋ค.
-Organizations can build and run scalable applications on public, private, and hybrid clouds using cloud native technologies.
+์กฐ์ง์ ํด๋ผ์ฐ๋ ๋ค์ดํฐ๋ธ ๊ธฐ์ ์ ์ฌ์ฉํ์ฌ ํผ๋ธ๋ฆญ, ํ๋ผ์ด๋น, ํ์ด๋ธ๋ฆฌ๋ ํด๋ผ์ฐ๋์์ ํ์ฅ ๊ฐ๋ฅํ ์ ํ๋ฆฌ์ผ์ด์
์ ๋น๋ํ๊ณ ์คํํ ์ ์์ต๋๋ค.
-This means the applications are designed to leverage cloud features, so they are resilient to load and easy to scale.
+์ด๋ฌํ ์ ํ๋ฆฌ์ผ์ด์
์ ํด๋ผ์ฐ๋ ๊ธฐ๋ฅ์ ํ์ฉํ๋๋ก ์ค๊ณ๋์ด ์์ด, ๋ก๋ฉ์ด ํ๋ ฅ์ ์ด๊ณ ์ฝ๊ฒ ํ์ฅํ ์ ์์ต๋๋ค.
-Cloud native includes 4 aspects:
+ํด๋ผ์ฐ๋ ๋ค์ดํฐ๋ธ์๋ 4๊ฐ์ง ์ธก๋ฉด์ด ์์ต๋๋ค.
1. Development process
This has progressed from waterfall to agile to DevOps.
+ ์ํฐํด์์ ์ ์์ผ, ๋ฐ๋ธ์ต์ค๋ก ๋ฐ์ ํด ์์ต๋๋ค.
2. Application Architecture
- The architecture has gone from monolithic to microservices. Each service is designed to be small, adaptive to the limited resources in cloud containers.
+ ์ํคํ
์ฒ๊ฐ ๋ชจ๋๋ฆฌ์ ์๋น์ค์์ ๋ง์ดํฌ๋ก ์๋น์ค๋ก ๋ฐ๋์์ต๋๋ค. ๊ฐ ์๋น์ค๋ ํด๋ผ์ฐ๋ ์ปจํ
์ด๋์ ์ ํ๋ ๋ฆฌ์์ค์ ๋ง๊ฒ ์๊ท๋ชจ๋ก ์กฐ์ ๋๋๋ก ์ค๊ณ๋์์ต๋๋ค.
3. Deployment & packaging
- The applications used to be deployed on physical servers. Then around 2000, the applications that were not sensitive to latency were usually deployed on virtual servers. With cloud native applications, they are packaged into docker images and deployed in containers.
+ ์์ ์๋ ์ ํ๋ฆฌ์ผ์ด์
์ด ๋ฌผ๋ฆฌ์ ์๋ฒ์ ๋ฐฐํฌ๋์์ต๋๋ค. ๊ทธ๋ฌ๋ค๊ฐ 2000๋
๊ฒฝ์๋ ์ง์ฐ ์๊ฐ์ ๋ฏผ๊ฐํ์ง ์์ ์ ํ๋ฆฌ์ผ์ด์
์ ๋ณดํต ๊ฐ์ ์๋ฒ์ ๋ฐฐํฌ๋์์ต๋๋ค. ํด๋ผ์ฐ๋ ๋ค์ดํฐ๋ธ ์ ํ๋ฆฌ์ผ์ด์
์ ๊ฒฝ์ฐ ๋์ปค ์ด๋ฏธ์ง๋ก ํจํค์ง๋์ด ์ปจํ
์ด๋์ ๋ฐฐํฌ๋ฉ๋๋ค.
4. Application infrastructure
- The applications are massively deployed on cloud infrastructure instead of self-hosted servers.
+ ์ ํ๋ฆฌ์ผ์ด์
์ ์์ฒด ํธ์คํ
์๋ฒ ๋์ ํด๋ผ์ฐ๋ ์ธํ๋ผ์ ๋๊ท๋ชจ๋ก ๋ฐฐํฌ๋ฉ๋๋ค.
-## Developer productivity tools
+## ๊ฐ๋ฐ์ ์์ฐ์ฑ ๋๊ตฌ
-### Visualize JSON files
+### JSON ํ์ผ ์๊ฐํ
-Nested JSON files are hard to read.
+์ค์ฒฉ๋ JSON ํ์ผ์ ์ฝ๊ธฐ ์ด๋ ต์ต๋๋ค.
-**JsonCrack** generates graph diagrams from JSON files and makes them easy to read.
+JSON ํ์ผ์์ ๊ทธ๋ํ ๋ค์ด์ด๊ทธ๋จ์ ์์ฑํ๊ณ ์ฝ๊ฒ ์ฝ์ ์ ์๋๋ก **JsonCrack**์ ์ ๊ณตํฉ๋๋ค.
-Additionally, the generated diagrams can be downloaded as images.
+๋ํ ์์ฑ๋ ๋ค์ด์ด๊ทธ๋จ์ ์ด๋ฏธ์ง๋ก ๋ค์ด๋ก๋ํ ์ ์์ต๋๋ค.
-### Automatically turn code into architecture diagrams
+### ์ฝ๋๋ฅผ ์ํคํ
์ฒ ๋ค์ด์ด๊ทธ๋จ์ผ๋ก ์๋ ๋ณํ
-What does it do?
+์ด๋ค ๊ธฐ๋ฅ์ด ์๋์?
-- Draw the cloud system architecture in Python code.
-- Diagrams can also be rendered directly inside the Jupyter Notebooks.
-- No design tools are needed.
-- Supports the following providers: AWS, Azure, GCP, Kubernetes, Alibaba Cloud, Oracle Cloud, etc.
+- Python ์ฝ๋๋ก ํด๋ผ์ฐ๋ ์์คํ
์ํคํ
์ฒ๋ฅผ ๊ทธ๋ฆฝ๋๋ค.
+- ๋ค์ด์ด๊ทธ๋จ์ ์ฃผํผํฐ ๋
ธํธ๋ถ์์ ๋ฐ๋ก ๋ ๋๋งํ ์๋ ์์ต๋๋ค.
+- ๋์์ธ ๋๊ตฌ๊ฐ ํ์ํ์ง ์์ต๋๋ค.
+- ๋ค์ ํ๋ก๋ฐ์ด๋๋ฅผ ์ง์ํฉ๋๋ค: AWS, Azure, GCP, Kubernetes, ์๋ฆฌ๋ฐ๋ฐ ํด๋ผ์ฐ๋, ์ค๋ผํด ํด๋ผ์ฐ๋ ๋ฑ.
[Github repo](https://github.com/mingrammer/diagrams)
-## Linux
+## ๋ฆฌ๋
์ค
-### Linux file system explained
+### ๋ฆฌ๋
์ค ํ์ผ ์์คํ
์ค๋ช
-The Linux file system used to resemble an unorganized town where individuals constructed their houses wherever they pleased. However, in 1994, the Filesystem Hierarchy Standard (FHS) was introduced to bring order to the Linux file system.
+์์ ์๋ Linux ํ์ผ ์์คํ
์ด ๊ฐ์ธ์ด ์ํ๋ ๊ณณ์ ์ง์ ์ง๋ ๋ฌด์ง์ํ ๋ง์๊ณผ ๋น์ทํ์ต๋๋ค. ํ์ง๋ง 1994๋
, ๋ฆฌ๋
์ค ํ์ผ ์์คํ
์ ์ง์๋ฅผ ๋ถ์ฌํ๊ธฐ ์ํด ํ์ผ์์คํ
๊ณ์ธต๊ตฌ์กฐ ํ์ค(FHS:Filesystem Hierarchy Standard)์ด ๋์
๋์์ต๋๋ค.
-By implementing a standard like the FHS, software can ensure a consistent layout across various Linux distributions. Nonetheless, not all Linux distributions strictly adhere to this standard. They often incorporate their own unique elements or cater to specific requirements.
-To become proficient in this standard, you can begin by exploring. Utilize commands such as "cd" for navigation and "ls" for listing directory contents. Imagine the file system as a tree, starting from the root (/). With time, it will become second nature to you, transforming you into a skilled Linux administrator.
+์ํํธ์จ์ด๋ FHS์ ๊ฐ์ ํ์ค์ ๊ตฌํํจ์ผ๋ก์จ ๋ค์ํ Linux ๋ฐฐํฌํ์์ ์ผ๊ด๋ ๋ ์ด์์์ ๋ณด์ฅํ ์ ์์ต๋๋ค. ํ์ง๋ง ๋ชจ๋ Linux ๋ฐฐํฌํ์ด ์ด ํ์ค์ ์๊ฒฉํ๊ฒ ์ค์ํ๋ ๊ฒ์ ์๋๋๋ค. ์์ฒด ๊ณ ์ ์๋ฆฌ๋จผํธ๋ฅผ ํตํฉํ๊ฑฐ๋ ํน์ ์๊ตฌ ์ฌํญ์ ์ถฉ์กฑํ๋ ๊ฒฝ์ฐ๊ฐ ๋ง์ต๋๋ค.
+์ด ํ์ค์ ๋ฅ์ํด์ง๋ ค๋ฉด ๋จผ์ ์ดํด๋ณด๋ ๊ฒ๋ถํฐ ์์ํ ์ ์์ต๋๋ค. ํ์์ ์ํด์๋ "cd", ๋๋ ํ ๋ฆฌ ๋ด์ฉ์ ๋์ดํ๋ ค๋ฉด "ls"์ ๊ฐ์ ์ปค๋งจ๋๋ฅผ ํ์ฉํ์ธ์. ํ์ผ ์์คํ
์ ๋ฃจํธ(/)์์ ์์ํ๋ ํธ๋ฆฌ๋ผ๊ณ ์์ํด ๋ณด์ธ์. ์๊ฐ์ด ์ง๋๋ฉด ์ต์ํด์ ธ์ ์๋ จ๋ Linux ๊ด๋ฆฌ์๋ก ๊ฑฐ๋ญ๋ ์ ์์ ๊ฒ์
๋๋ค.
-### 18 Most-used Linux Commands You Should Know
+### ๊ฐ์ฅ ๋ง์ด ์ฌ์ฉ๋๋ 18๊ฐ์ง ๋ฆฌ๋
์ค ์ปค๋งจ๋ ์์๋ณด๊ธฐ
-Linux commands are instructions for interacting with the operating system. They help manage files, directories, system processes, and many other aspects of the system. You need to become familiar with these commands in order to navigate and maintain Linux-based systems efficiently and effectively.
+Linux ์ปค๋งจ๋๋ ์ด์ ์ฒด์ ์ ์ํธ ์์ฉํ๊ธฐ ์ํ ์ธ์คํฐ๋ญ์
์
๋๋ค. ํ์ผ, ๋๋ ํ ๋ฆฌ, ์์คํ
ํ๋ก์ธ์ค ๋ฐ ๊ธฐํ ์์คํ
์ ์ฌ๋ฌ ์ธก๋ฉด์ ๊ด๋ฆฌํ๋ ๋ฐ ๋์์ด ๋ฉ๋๋ค. Linux ๊ธฐ๋ฐ ์์คํ
์ ํจ์จ์ ์ด๊ณ ํจ๊ณผ์ ์ผ๋ก ํ์ํ๊ณ ์ ์ง ๊ด๋ฆฌํ๋ ค๋ฉด ์ด๋ฌํ ์ปค๋งจ๋์ ์ต์ํด์ ธ์ผ ํฉ๋๋ค.
-This diagram below shows popular Linux commands:
+์๋ ๋ค์ด์ด๊ทธ๋จ์ ์์ฃผ ์ฌ์ฉ๋๋ Linux ์ปค๋งจ๋์
๋๋ค.
-- ls - List files and directories
-- cd - Change the current directory
-- mkdir - Create a new directory
-- rm - Remove files or directories
-- cp - Copy files or directories
-- mv - Move or rename files or directories
-- chmod - Change file or directory permissions
-- grep - Search for a pattern in files
-- find - Search for files and directories
-- tar - manipulate tarball archive files
-- vi - Edit files using text editors
-- cat - display the content of files
-- top - Display processes and resource usage
-- ps - Display processes information
-- kill - Terminate a process by sending a signal
-- du - Estimate file space usage
-- ifconfig - Configure network interfaces
-- ping - Test network connectivity between hosts
+- ls - ํ์ผ๊ณผ ๋๋ ํ ๋ฆฌ ๋ชฉ๋ก
+- cd - ํ์ฌ ๋๋ ํ ๋ฆฌ ๋ณ๊ฒฝ
+- mkdir - ์๋ก์ด ๋๋ ํ ๋ฆฌ ์์ฑ
+- rm - ํ์ผ ๋๋ ๋๋ ํ ๋ฆฌ ์ ๊ฑฐ
+- cp - ํ์ผ ๋๋ ๋๋ ํ ๋ฆฌ ๋ณต์ฌ
+- mv - ํ์ผ ๋๋ ๋๋ ํ ๋ฆฌ ์ด๋ฆ๋ณ๊ฒฝ ํน์ ์ด๋
+- chmod - ํ์ผ ๋๋ ๋๋ ํ ๋ฆฌ ๊ถํ ๊ด๋ฆฌ
+- grep - ํ์ผ์์ ํจํด ๊ฒ์
+- find - ํ์ผ๊ณผ ๋๋ ํ ๋ฆฌ ๊ฒ์
+- tar - tarball ์์นด์ด๋ธ ํ์ผ ์กฐ์
+- vi - ํ
์คํธ ์๋ํฐ๋ฅผ ์ฌ์ฉํ์ฌ ํ์ผ ํธ์ง
+- cat - ํ์ผ์ ์ฝํ
์ธ ํ์
+- top - ํ๋ก์ธ์ค ๋ฆฌ์์ค ์ฌ์ฉ๋ ํ์
+- ps - ํ๋ก์ธ์ ์ ๋ณด ํ์
+- kill - ์ ํธ๋ฅผ ์ ์กํ์ฌ ํ๋ก์ธ์ค ์ข
๋ฃ
+- du - ํ์ผ ์ฉ๋ ์ฌ์ฉ๋ ์ถ์
+- ifconfig - ๋คํธ์ํฌ ์ธํฐํ์ด์ค ์ค์
+- ping - ํธ์คํธ ๊ฐ ๋คํธ์ํฌ ์ปค๋ฅ์
ํ
์คํธ
## Security
From 5d2233df4cd47317bec3b8eeaf9618a2f1fc4fa4 Mon Sep 17 00:00:00 2001
From: kei kim
Date: Wed, 31 Jan 2024 18:17:37 +0900
Subject: [PATCH 12/16] docs: translate to security
---
translations/README-kr.md | 170 +++++++++++++++++++-------------------
1 file changed, 85 insertions(+), 85 deletions(-)
diff --git a/translations/README-kr.md b/translations/README-kr.md
index 899aba3..9c85803 100644
--- a/translations/README-kr.md
+++ b/translations/README-kr.md
@@ -86,14 +86,14 @@
- [๋ฆฌ๋
์ค](#๋ฆฌ๋
์ค)
- [๋ฆฌ๋
์ค ํ์ผ ์์คํ
์ค๋ช
](#๋ฆฌ๋
์ค-ํ์ผ-์์คํ
-์ค๋ช
)
- [๊ฐ์ฅ ๋ง์ด ์ฌ์ฉ๋๋ 18๊ฐ์ง ๋ฆฌ๋
์ค ์ปค๋งจ๋ ์์๋ณด๊ธฐ](#๊ฐ์ฅ-๋ง์ด-์ฌ์ฉ๋๋-18๊ฐ์ง-๋ฆฌ๋
์ค-์ปค๋งจ๋-์์๋ณด๊ธฐ)
-- [๋ณด์](#security)
- - [HTTPS๋ ์ด๋ป๊ฒ ์๋ํ๋์?](#how-does-https-work)
- - [๊ฐ๋จํ ์ฉ์ด๋ก ์ค๋ช
ํ๋ Oauth 2.0](#oauth-20-explained-with-simple-terms)
- - [์ธ์ฆ ๋ฉ์ปค๋์ฆ์ 4๊ฐ์ง ์ฃผ์ ํํ](#top-4-forms-of-authentication-mechanisms)
- - [Session, cookie, JWT, token, SSO, OAuth 2.0 - ๊ทธ๊ฒ ๋ญ๊ฐ์?](#session-cookie-jwt-token-sso-and-oauth-20---what-are-they)
- - [๋ฐ์ดํฐ๋ฒ ์ด์ค์ ๋น๋ฐ๋ฒํธ๋ฅผ ์์ ํ๊ฒ ์ ์ฅํ๋ ๋ฐฉ๋ฒ๊ณผ ๋น๋ฐ๋ฒํธ๋ฅผ ํ์ธํ๋ ๋ฐฉ๋ฒ์ ๋ฌด์์ธ๊ฐ์?](#how-to-store-passwords-safely-in-the-database-and-how-to-validate-a-password)
- - [10์ธ ์ด๋ฆฐ์ด์๊ฒ JSON Web Token(JWT) ์ค๋ช
ํ๊ธฐ](#explaining-json-web-token-jwt-to-a-10-year-old-kid)
- - [Google authenticator(๋๋ ๋ค๋ฅธ ์ ํ์ 2 factor authenticator)๋ ์ด๋ป๊ฒ ์๋ํ๋์?](#how-does-google-authenticator-or-other-types-of-2-factor-authenticators-work)
+- [๋ณด์](#๋ณด์)
+ - [HTTPS๋ ์ด๋ป๊ฒ ์๋ํ๋์?](#https๋-์ด๋ป๊ฒ-์๋ํ๋์)
+ - [๊ฐ๋จํ ์ฉ์ด๋ก ์ค๋ช
ํ๋ Oauth 2.0](#๊ฐ๋จํ-์ฉ์ด๋ก-์ค๋ช
ํ๋-oauth-20)
+ - [์ธ์ฆ ๋ฉ์ปค๋์ฆ์ 4๊ฐ์ง ์ฃผ์ ํํ](#์ธ์ฆ-๋ฉ์ปค๋์ฆ์-4๊ฐ์ง-์ฃผ์-ํํ)
+ - [Session, cookie, JWT, token, SSO, OAuth 2.0 - ๊ทธ๊ฒ ๋ญ๊ฐ์?](#session-cookie-jwt-token-sso-oauth-20---๊ทธ๊ฒ-๋ญ๊ฐ์)
+ - [๋ฐ์ดํฐ๋ฒ ์ด์ค์ ๋น๋ฐ๋ฒํธ๋ฅผ ์์ ํ๊ฒ ์ ์ฅํ๋ ๋ฐฉ๋ฒ๊ณผ ๋น๋ฐ๋ฒํธ๋ฅผ ํ์ธํ๋ ๋ฐฉ๋ฒ์ ๋ฌด์์ธ๊ฐ์?](#๋ฐ์ดํฐ๋ฒ ์ด์ค์-๋น๋ฐ๋ฒํธ๋ฅผ-์์ ํ๊ฒ-์ ์ฅํ๋-๋ฐฉ๋ฒ๊ณผ-๋น๋ฐ๋ฒํธ๋ฅผ-ํ์ธํ๋-๋ฐฉ๋ฒ์-๋ฌด์์ธ๊ฐ์)
+ - [10์ธ ์ด๋ฆฐ์ด์๊ฒ JSON Web Token(JWT) ์ค๋ช
ํ๊ธฐ](#10์ธ-์ด๋ฆฐ์ด์๊ฒ-json-web-tokenjwt-์ค๋ช
ํ๊ธฐ)
+ - [Google authenticator(๋๋ ๋ค๋ฅธ ์ ํ์ 2 factor authenticator)๋ ์ด๋ป๊ฒ ์๋ํ๋์?](#google-authenticator๋๋-๋ค๋ฅธ-์ ํ์-2-factor-authenticator๋-์ด๋ป๊ฒ-์๋ํ๋์)
- [์ค์ ์ฌ๋ก ์ฐ๊ตฌ](#real-world-case-studies)
- [๋ทํ๋ฆญ์ค ๊ธฐ์ ์คํ](#netflixs-tech-stack)
- [ํธ์ํฐ ์ํคํ
์ฒ 2022](#twitter-architecture-2022)
@@ -1307,58 +1307,58 @@ Linux ์ปค๋งจ๋๋ ์ด์ ์ฒด์ ์ ์ํธ ์์ฉํ๊ธฐ ์ํ ์ธ์คํฐ๋ญ์
- ifconfig - ๋คํธ์ํฌ ์ธํฐํ์ด์ค ์ค์
- ping - ํธ์คํธ ๊ฐ ๋คํธ์ํฌ ์ปค๋ฅ์
ํ
์คํธ
-## Security
+## ๋ณด์
-### How does HTTPS work?
+### HTTPS๋ ์ด๋ป๊ฒ ์๋ํ๋์?
-Hypertext Transfer Protocol Secure (HTTPS) is an extension of the Hypertext Transfer Protocol (HTTP.) HTTPS transmits encrypted data using Transport Layer Security (TLS.) If the data is hijacked online, all the hijacker gets is binary code.
+Hypertext Transfer Protocol Secure(HTTPS)๋ Hypertext Transfer Protocol(HTTP)์ ํ์ฅ์
๋๋ค. HTTPS๋ Transport Layer Security(TLS)๋ฅผ ์ฌ์ฉํ์ฌ ์ํธํ๋ ๋ฐ์ดํฐ๋ฅผ ์ ์กํฉ๋๋ค. ์จ๋ผ์ธ์์ ๋ฐ์ดํฐ๋ฅผ ํ์ทจ๋นํ๋ฉด ํ์ทจ์๊ฐ ์ป๋ ๊ฒ์ ๋ฐ์ด๋๋ฆฌ ์ฝ๋๋ฟ์
๋๋ค.
-How is the data encrypted and decrypted?
+๋ฐ์ดํฐ๋ ์ด๋ป๊ฒ ์ํธํ๋๊ณ ๋ณตํธํ๋๋์?
-Step 1 - The client (browser) and the server establish a TCP connection.
+1๋จ๊ณ - ํด๋ผ์ด์ธํธ(๋ธ๋ผ์ฐ์ )์ ์๋ฒ๊ฐ TCP ์ปค๋ฅ์
์ ์ค์ ํฉ๋๋ค.
-Step 2 - The client sends a โclient helloโ to the server. The message contains a set of necessary encryption algorithms (cipher suites) and the latest TLS version it can support. The server responds with a โserver helloโ so the browser knows whether it can support the algorithms and TLS version.
+2๋จ๊ณ - ํด๋ผ์ด์ธํธ๊ฐ ์๋ฒ์ "client hello"๋ฅผ ๋ณด๋
๋๋ค. ์ด ๋ฉ์์ง์๋ ํ์ํ ์ํธํ ์๊ณ ๋ฆฌ์ฆ(cipher suites) ์ธํธ์ ์ง์ํ ์ ์๋ ์ต์ TLS ๋ฒ์ ์ด ํฌํจ๋ฉ๋๋ค. ์๋ฒ๋ "server hello"๋ก ์๋ตํ์ฌ ๋ธ๋ผ์ฐ์ ๊ฐ ํด๋น ์๊ณ ๋ฆฌ์ฆ๊ณผ TLS ๋ฒ์ ์ ์ง์ํ ์ ์๋์ง ์ฌ๋ถ๋ฅผ ์ ์ ์์ต๋๋ค.
-The server then sends the SSL certificate to the client. The certificate contains the public key, host name, expiry dates, etc. The client validates the certificate.
+๊ทธ๋ฌ๋ฉด ์๋ฒ๊ฐ ํด๋ผ์ด์ธํธ์ SSL ์ธ์ฆ์๋ฅผ ๋ณด๋
๋๋ค. ์ธ์ฆ์์๋ ๊ณต๊ฐ ํค, ํธ์คํธ ์ด๋ฆ, ๋ง๋ฃ ๋ ์ง ๋ฑ์ด ํฌํจ๋ฉ๋๋ค. ํด๋ผ์ด์ธํธ๋ ์ธ์ฆ์์ ์ ํจ์ฑ์ ๊ฒ์ฌํฉ๋๋ค.
-Step 3 - After validating the SSL certificate, the client generates a session key and encrypts it using the public key. The server receives the encrypted session key and decrypts it with the private key.
+3๋จ๊ณ - SSL ์ธ์ฆ์์ ์ ํจ์ฑ์ ๊ฒ์ฌํ ํ ํด๋ผ์ด์ธํธ๋ ์ธ์
ํค๋ฅผ ์์ฑํ๊ณ ๊ณต๊ฐ ํค๋ฅผ ์ฌ์ฉํ์ฌ ์ํธํํฉ๋๋ค. ์๋ฒ๋ ์ํธํ๋ ์ธ์
ํค๋ฅผ ์์ ํ๊ณ ๊ฐ์ธ ํค๋ก ์ํธ๋ฅผ ํด๋
ํฉ๋๋ค.
-Step 4 - Now that both the client and the server hold the same session key (symmetric encryption), the encrypted data is transmitted in a secure bi-directional channel.
+4๋จ๊ณ - ์ด์ ํด๋ผ์ด์ธํธ์ ์๋ฒ๊ฐ ๋ชจ๋ ๋์ผํ ์ธ์
ํค(๋์นญ ์ํธํ)๋ฅผ ๋ณด์ ํ๋ฏ๋ก ์ํธํ๋ ๋ฐ์ดํฐ๋ ์์ ํ ์๋ฐฉํฅ ์ฑ๋๋ก ์ ์ก๋ฉ๋๋ค.
-Why does HTTPS switch to symmetric encryption during data transmission? There are two main reasons:
+๋ฐ์ดํฐ ์ ์ก ์ค์ HTTPS๊ฐ ๋์นญ ์ํธํ๋ก ์ ํ๋๋ ์ด์ ๋ ๋ฌด์์ธ๊ฐ์? ๋ ๊ฐ์ง ์ฃผ์ ์ด์ ๊ฐ ์์ต๋๋ค.
-1. Security: The asymmetric encryption goes only one way. This means that if the server tries to send the encrypted data back to the client, anyone can decrypt the data using the public key.
+1. ๋ณด์: ๋น๋์นญ ์ํธํ๋ ํ ๋ฐฉํฅ์ผ๋ก๋ง ์งํ๋ฉ๋๋ค. ์ฆ, ์๋ฒ๊ฐ ์ํธํ๋ ๋ฐ์ดํฐ๋ฅผ ํด๋ผ์ด์ธํธ๋ก ๋ค์ ๋ณด๋ด๋ ค๊ณ ํ๋ฉด ๋๊ตฌ๋ ๊ณต๊ฐ ํค๋ฅผ ์ฌ์ฉํ์ฌ ๋ฐ์ดํฐ๋ฅผ ํด๋
ํ ์ ์์ต๋๋ค.
-2. Server resources: The asymmetric encryption adds quite a lot of mathematical overhead. It is not suitable for data transmissions in long sessions.
+2. ์๋ฒ ๋ฆฌ์์ค: ๋น๋์นญ ์ํธํ๋ ์๋นํ ์ํ์ ์ค๋ฒํค๋๋ฅผ ์ถ๊ฐํฉ๋๋ค. ๊ธด ์ธ์
์ ๋ฐ์ดํฐ ์ ์ก์๋ ์ ํฉํ์ง ์์ต๋๋ค.
-### Oauth 2.0 Explained With Simple Terms.
+### ๊ฐ๋จํ ์ฉ์ด๋ก ์ค๋ช
ํ๋ Oauth 2.0
-OAuth 2.0 is a powerful and secure framework that allows different applications to securely interact with each other on behalf of users without sharing sensitive credentials.
+OAuth 2.0์ ๊ฐ๋ ฅํ๊ณ ์์ ํ ํ๋ ์์ํฌ๋ก, ์ฌ๋ฌ ์ ํ๋ฆฌ์ผ์ด์
์ด ๋ฏผ๊ฐํ ์๊ฒฉ ์ฆ๋ช
์ ๊ณต์ ํ์ง ์๊ณ ๋ ์ฌ์ฉ์๋ฅผ ๋์ ํ์ฌ ์๋ก ์์ ํ๊ฒ ์ํธ ์์ฉํ ์ ์๊ฒ ํด์ค๋๋ค.
-The entities involved in OAuth are the User, the Server, and the Identity Provider (IDP).
+OAuth์ ์ฐธ์ฌํ๋ ๊ฐ์ฒด๋ ์ฌ์ฉ์, ์๋ฒ, ID ๊ณต๊ธ์(Identity Provider, IDP)์
๋๋ค.
-What Can an OAuth Token Do?
+OAuth ํ ํฐ์ ๋ฌด์์ ํ ์ ์๋์?
-When you use OAuth, you get an OAuth token that represents your identity and permissions. This token can do a few important things:
+OAuth๋ฅผ ์ฌ์ฉํ๋ฉด ์ ์ ๋ฐ ๊ถํ์ ๋ํ๋ด๋ OAuth ํ ํฐ์ ๋ฐ๊ฒ ๋ฉ๋๋ค. ์ด ํ ํฐ์ ๋ช ๊ฐ์ง ์ค์ํ ์์
์ ์ํํ ์ ์์ต๋๋ค.
-Single Sign-On (SSO): With an OAuth token, you can log into multiple services or apps using just one login, making life easier and safer.
+Single Sign-On(SSO): OAuth ํ ํฐ์ ์ฌ์ฉํ๋ฉด ํ ๋ฒ์ ๋ก๊ทธ์ธ์ผ๋ก ์ฌ๋ฌ ์๋น์ค๋ ์ฑ์ ๋ก๊ทธ์ธํ ์ ์์ด ๋์ฑ ์ฝ๊ณ ์์ ํ๊ฒ ์ํํ ์ ์์ต๋๋ค.
-Authorization Across Systems: The OAuth token allows you to share your authorization or access rights across various systems, so you don't have to log in separately everywhere.
+Authorization Across Systems: ์์คํ
๊ฐ ์ธ์ฆ: OAuth ํ ํฐ์ ์ฌ์ฉํ๋ฉด ๋ค์ํ ์์คํ
์์ ์ธ์ฆ ๋๋ ์ก์ธ์ค ๊ถํ์ ๊ณต์ ํ ์ ์์ผ๋ฏ๋ก ๋ชจ๋ ์์คํ
์์ ๋ณ๋๋ก ๋ก๊ทธ์ธํ ํ์๊ฐ ์์ต๋๋ค.
-Accessing User Profile: Apps with an OAuth token can access certain parts of your user profile that you allow, but they won't see everything.
+Accessing User Profile: OAuth ํ ํฐ์ด ์๋ ์ฑ์ ์ฌ์ฉ์๊ฐ ํ์ฉํ ์ฌ์ฉ์ ํ๋กํ์ ํน์ ๋ถ๋ถ์ ์ก์ธ์คํ ์ ์์ง๋ง ๋ชจ๋ ๋ถ๋ถ์ ๋ณผ ์๋ ์์ต๋๋ค.
-Remember, OAuth 2.0 is all about keeping you and your data safe while making your online experiences seamless and hassle-free across different applications and services.
+OAuth 2.0์ ์ฌ์ฉ์์ ์ฌ์ฉ์์ ๋ฐ์ดํฐ๋ฅผ ์์ ํ๊ฒ ๋ณดํธํ๋ ๋์์ ๋ค์ํ ์ ํ๋ฆฌ์ผ์ด์
๊ณผ ์๋น์ค์์ ์ํํ๊ณ ๋ฒ๊ฑฐ๋ก์ ์๋ ์จ๋ผ์ธ ๊ฒฝํ์ ์ ๊ณตํ๋ ๋ฐ ์ค์ ์ ๋๊ณ ์์ต๋๋ค.
-### Top 4 Forms of Authentication Mechanisms
+### ์ธ์ฆ ๋ฉ์ปค๋์ฆ์ 4๊ฐ์ง ์ฃผ์ ํํ
@@ -1366,132 +1366,132 @@ Remember, OAuth 2.0 is all about keeping you and your data safe while making you
1. SSH Keys:
- Cryptographic keys are used to access remote systems and servers securely
+ ์ํธํ ํค๋ ์๊ฒฉ ์์คํ
๋ฐ ์๋ฒ์ ์์ ํ๊ฒ ์ก์ธ์คํ๋ ๋ฐ ์ฌ์ฉ๋ฉ๋๋ค.
1. OAuth Tokens:
- Tokens that provide limited access to user data on third-party applications
+ ์จ๋ํํฐ ์ ํ๋ฆฌ์ผ์ด์
์ ์ฌ์ฉ์ ๋ฐ์ดํฐ์ ๋ํ ์ ํ๋ ์ก์ธ์ค๋ฅผ ์ ๊ณตํ๋ ํ ํฐ์
๋๋ค.
1. SSL Certificates:
- Digital certificates ensure secure and encrypted communication between servers and clients
+ ๋์งํธ ์ธ์ฆ์๋ ์๋ฒ์ ํด๋ผ์ด์ธํธ ๊ฐ์ ์์ ํ ์ํธํ๋ ํต์ ์ ๋ณด์ฅํฉ๋๋ค.
1. Credentials:
- User authentication information is used to verify and grant access to various systems and services
+ ์ฌ์ฉ์ ์ธ์ฆ ์ ๋ณด๋ ๋ค์ํ ์์คํ
๊ณผ ์๋น์ค์ ๋ํ ์ก์ธ์ค ๊ถํ์ ํ์ธํ๊ณ ๋ถ์ฌํ๋ ๋ฐ ์ฌ์ฉ๋ฉ๋๋ค.
-### Session, cookie, JWT, token, SSO, and OAuth 2.0 - what are they?
+### Session, cookie, JWT, token, SSO, OAuth 2.0 - ๊ทธ๊ฒ ๋ญ๊ฐ์?
-These terms are all related to user identity management. When you log into a website, you declare who you are (identification). Your identity is verified (authentication), and you are granted the necessary permissions (authorization). Many solutions have been proposed in the past, and the list keeps growing.
+์ด ์ฝ๊ด์ ๋ชจ๋ ์ฌ์ฉ์ ์ ์ ๊ด๋ฆฌ์ ๊ด๋ จ์ด ์์ต๋๋ค. ์น์ฌ์ดํธ์ ๋ก๊ทธ์ธํ ๋ ์ฌ์ฉ์๋ ์์ ์ด ๋๊ตฌ์ธ์ง๋ฅผ ์ ์ธํฉ๋๋ค(์๋ณ). ์ฌ์ฉ์์ ์ ์์ ํ์ธํ๊ณ (์ธ์ฆ) ํ์ํ ๊ถํ์ ๋ถ์ฌํฉ๋๋ค(์ธ๊ฐ). ๊ณผ๊ฑฐ์ ๋ง์ ์๋ฃจ์
์ด ์ ์๋์๊ณ ๊ทธ ๋ชฉ๋ก์ ๊ณ์ ๋์ด๋๊ณ ์์ต๋๋ค.
-From simple to complex, here is my understanding of user identity management:
+๊ฐ๋จํ ๊ฒ๋ถํฐ ๋ณต์กํ ๊ฒ๊น์ง, ์ฌ์ฉ์ ์ ์ ๊ด๋ฆฌ์ ๋ํ ์ ์ ์ดํด๋ฅผ ์ ๋ฆฌํด ๋ณด์์ต๋๋ค.
-- WWW-Authenticate is the most basic method. You are asked for the username and password by the browser. As a result of the inability to control the login life cycle, it is seldom used today.
+- WWW-์ธ์ฆ์ ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ๋ฐฉ๋ฒ์
๋๋ค. ๋ธ๋ผ์ฐ์ ์์ ์ฌ์ฉ์ ์ด๋ฆ๊ณผ ๋น๋ฐ๋ฒํธ๋ฅผ ์
๋ ฅํ๋ผ๋ ๋ฉ์์ง๊ฐ ํ์๋ฉ๋๋ค. ๋ก๊ทธ์ธ ์๋ช
์ฃผ๊ธฐ๋ฅผ ์ ์ดํ ์ ์๊ธฐ ๋๋ฌธ์ ์ค๋๋ ์๋ ๊ฑฐ์ ์ฌ์ฉ๋์ง ์์ต๋๋ค.
-- A finer control over the login life cycle is session-cookie. The server maintains session storage, and the browser keeps the ID of the session. A cookie usually only works with browsers and is not mobile app friendly.
+- ๋ก๊ทธ์ธ ์๋ช
์ฃผ๊ธฐ๋ฅผ ๋ณด๋ค ์ธ๋ฐํ๊ฒ ์ ์ดํ ์ ์๋ ๋ฐฉ๋ฒ์ ์ธ์
์ฟ ํค์
๋๋ค. ์๋ฒ๋ ์ธ์
์ ์ฅ์๋ฅผ ์ ์งํ๊ณ ๋ธ๋ผ์ฐ์ ๋ ์ธ์
์ ID๋ฅผ ์ ์งํฉ๋๋ค. ์ฟ ํค๋ ์ผ๋ฐ์ ์ผ๋ก ๋ธ๋ผ์ฐ์ ์์๋ง ์๋ํ๋ฉฐ ๋ชจ๋ฐ์ผ ์ฑ์๋ ์ ํฉํ์ง ์์ต๋๋ค.
-- To address the compatibility issue, the token can be used. The client sends the token to the server, and the server validates the token. The downside is that the token needs to be encrypted and decrypted, which may be time-consuming.
+- ํธํ์ฑ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด ํ ํฐ์ ์ฌ์ฉํ ์ ์์ต๋๋ค. ํด๋ผ์ด์ธํธ๊ฐ ํ ํฐ์ ์๋ฒ๋ก ์ ์กํ๋ฉด ์๋ฒ๊ฐ ํ ํฐ์ ์ ํจ์ฑ์ ๊ฒ์ฌํฉ๋๋ค. ๋จ์ ์ ํ ํฐ์ ์ํธํํ๊ณ ํด๋
ํด์ผ ํ๋ฏ๋ก ์๊ฐ์ด ์ค๋ ๊ฑธ๋ฆด ์ ์๋ค๋ ๊ฒ์
๋๋ค.
-- JWT is a standard way of representing tokens. This information can be verified and trusted because it is digitally signed. Since JWT contains the signature, there is no need to save session information on the server side.
+- JWT๋ ํ ํฐ์ ๋ํ๋ด๋ ํ์ค ๋ฐฉ์์
๋๋ค. ์ด ์ ๋ณด๋ ๋์งํธ ์๋ช
์ด ๋์ด ์๊ธฐ ๋๋ฌธ์ ๊ฒ์ฆ๋๊ณ ์ ๋ขฐํ ์ ์์ต๋๋ค. JWT์๋ ์๋ช
์ด ํฌํจ๋์ด ์์ผ๋ฏ๋ก ์๋ฒ ์ธก์ ์ธ์
์ ๋ณด๋ฅผ ์ ์ฅํ ํ์๊ฐ ์์ต๋๋ค.
-- By using SSO (single sign-on), you can sign on only once and log in to multiple websites. It uses CAS (central authentication service) to maintain cross-site information.
+- SSO( Single Sign-On)์ ์ฌ์ฉํ๋ฉด ํ ๋ฒ๋ง ๋ก๊ทธ์จํ์ฌ ์ฌ๋ฌ ์น์ฌ์ดํธ์ ๋ก๊ทธ์ธํ ์ ์์ต๋๋ค. CAS( Central Authentication Service)๋ฅผ ์ฌ์ฉํ์ฌ ์ฌ์ดํธ ๊ฐ ์ ๋ณด๋ฅผ ์ ์ง ๊ด๋ฆฌํฉ๋๋ค.
-- By using OAuth 2.0, you can authorize one website to access your information on another website.
+- OAuth 2.0์ ์ฌ์ฉํ๋ฉด ํ ์น์ฌ์ดํธ๊ฐ ๋ค๋ฅธ ์น์ฌ์ดํธ์์ ๋ด ์ ๋ณด์ ์ก์ธ์คํ ์ ์๋๋ก ์ธ์ฆํ ์ ์์ต๋๋ค.
-### How to store passwords safely in the database and how to validate a password?
+### ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ๋น๋ฐ๋ฒํธ๋ฅผ ์์ ํ๊ฒ ์ ์ฅํ๋ ๋ฐฉ๋ฒ๊ณผ ๋น๋ฐ๋ฒํธ๋ฅผ ํ์ธํ๋ ๋ฐฉ๋ฒ์ ๋ฌด์์ธ๊ฐ์?
-**Things NOT to do**
+**ํ์ง ๋ง์์ผ ํ ๊ฒ๋ค**
-- Storing passwords in plain text is not a good idea because anyone with internal access can see them.
+- ๋น๋ฐ๋ฒํธ๋ฅผ ์ผ๋ฐ ํ
์คํธ๋ก ์ ์ฅํ๋ ๊ฒ์ ๋ด๋ถ ์ก์ธ์ค ๊ถํ์ด ์๋ ๋ชจ๋ ์ฌ๋์ด ๋ณผ ์ ์์ผ๋ฏ๋ก ์ข์ ์๊ฐ์ด ์๋๋๋ค.
-- Storing password hashes directly is not sufficient because it is pruned to precomputation attacks, such as rainbow tables.
+- ๋น๋ฐ๋ฒํธ ํด์๋ฅผ ์ง์ ์ ์ฅํ๋ ๊ฒ์ ๋ ์ธ๋ณด์ฐ ํ
์ด๋ธ๊ณผ ๊ฐ์ ์ฌ์ ๊ณ์ฐ ๊ณต๊ฒฉ์ ์ทจ์ฝํ๊ธฐ ๋๋ฌธ์ ์ถฉ๋ถํ์ง ์์ต๋๋ค.
-- To mitigate precomputation attacks, we salt the passwords.
+- precomputation attacks์ ์ํํ๊ธฐ ์ํด ๋น๋ฐ๋ฒํธ๋ฅผ ์ํธ ์ฒ๋ฆฌํฉ๋๋ค.
-**What is salt?**
+**salt๋ ๋ฌด์์ธ๊ฐ์?**
-According to OWASP guidelines, โa salt is a unique, randomly generated string that is added to each password as part of the hashing processโ.
+OWASP ๊ฐ์ด๋๋ผ์ธ์ ๋ฐ๋ฅด๋ฉด "์ํธ๋ ํด์ฑ ํ๋ก์ธ์ค์ ์ผ๋ถ๋ก ๊ฐ ๋น๋ฐ๋ฒํธ์ ์ถ๊ฐ๋๋ ๊ณ ์ ํ๊ณ ๋ฌด์์๋ก ์์ฑ๋๋ ๋ฌธ์์ด"์
๋๋ค.
-**How to store a password and salt?**
+**๋น๋ฐ๋ฒํธ์ salt๋ฅผ ์ ์ฅํ๋ ๋ฐฉ๋ฒ์ ๋ฌด์์ธ๊ฐ์?**
-1. the hash result is unique to each password.
-1. The password can be stored in the database using the following format: hash(password + salt).
+1. ํด์ ๊ฒฐ๊ณผ๋ ๊ฐ ๋น๋ฐ๋ฒํธ๋ง๋ค ๊ณ ์ ํฉ๋๋ค.
+1. ๋น๋ฐ๋ฒํธ๋ ๋ค์ ํฌ๋งท์ ์ฌ์ฉํ์ฌ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ์ ์ฅํ ์ ์์ต๋๋ค. ํด์(password + salt).
-**How to validate a password?**
+**๋น๋ฐ๋ฒํธ๋ ์ด๋ป๊ฒ ํ์ธํ๋์?**
-To validate a password, it can go through the following process:
+๋น๋ฐ๋ฒํธ์ ์ ํจ์ฑ์ ๊ฒ์ฌํ๋ ค๋ฉด ๋ค์ ๊ณผ์ ์ ๊ฑฐ์น ์ ์์ต๋๋ค.
-1. A client enters the password.
-1. The system fetches the corresponding salt from the database.
-1. The system appends the salt to the password and hashes it. Letโs call the hashed value H1.
-1. The system compares H1 and H2, where H2 is the hash stored in the database. If they are the same, the password is valid.
+1. ํด๋ผ์ด์ธํธ์์ ํจ์ค์๋๋ฅผ ์
๋ ฅํฉ๋๋ค.
+1. ์์คํ
์ ๋ฐ์ดํฐ๋ฒ ์ด์ค์์ ํด๋น salt๋ฅผ ๊ฐ์ ธ์ต๋๋ค.
+1. ์์คํ
์ด ๋น๋ฐ๋ฒํธ์ salt๋ฅผ ์ถ๊ฐํ๊ณ ํด์๋ก ๋ง๋ญ๋๋ค. ํด์๋ ๊ฐ์ H1์ด๋ผ๊ณ ๋ถ๋ฅด๊ฒ ์ต๋๋ค.
+1. ์์คํ
์ H1๊ณผ H2๋ฅผ ๋น๊ตํ๋๋ฐ, ์ฌ๊ธฐ์ H2๋ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ์ ์ฅ๋ ํด์์
๋๋ค. ๋์ด ๊ฐ์ผ๋ฉด ๋น๋ฐ๋ฒํธ๊ฐ ์ ํจํ ๊ฒ์
๋๋ค.
-### Explaining JSON Web Token (JWT) to a 10 year old Kid
+### 10์ธ ์ด๋ฆฐ์ด์๊ฒ JSON Web Token(JWT) ์ค๋ช
ํ๊ธฐ
-Imagine you have a special box called a JWT. Inside this box, there are three parts: a header, a payload, and a signature.
+JWT๋ผ๋ ํน๋ณํ ์์๊ฐ ์๋ค๊ณ ์์ํด ๋ณด์ธ์. ์ด ์์ ์์๋ ํค๋, ํ์ด๋ก๋, ์๋ช
์ธ ๋ถ๋ถ์ด ์์ต๋๋ค.
-The header is like the label on the outside of the box. It tells us what type of box it is and how it's secured. It's usually written in a format called JSON, which is just a way to organize information using curly braces { } and colons : .
+ํค๋๋ ์์ ์ธ๋ถ์ ๋ผ๋ฒจ๊ณผ ๊ฐ์ ์ญํ ์ ํฉ๋๋ค. ํค๋๋ ์์์ ํ์
๊ณผ ๋ณด์ ๋ฐฉ๋ฒ์ ์๋ ค์ค๋๋ค. ์ผ๋ฐ์ ์ผ๋ก ์ค๊ดํธ { }์ ์ฝ๋ก : ์ ์ฌ์ฉํ์ฌ ์ ๋ณด๋ฅผ ์ ๋ฆฌํ๋ ๋ฐฉ๋ฒ์ธ JSON์ด๋ผ๋ ํฌ๋งท์ผ๋ก ์์ฑ๋ฉ๋๋ค.
-The payload is like the actual message or information you want to send. It could be your name, age, or any other data you want to share. It's also written in JSON format, so it's easy to understand and work with.
-Now, the signature is what makes the JWT secure. It's like a special seal that only the sender knows how to create. The signature is created using a secret code, kind of like a password. This signature ensures that nobody can tamper with the contents of the JWT without the sender knowing about it.
+ํ์ด๋ก๋๋ ์ ์กํ๋ ค๋ ์ค์ ๋ฉ์์ง ๋๋ ์ ๋ณด์ ๊ฐ์ต๋๋ค. ์ด๋ฆ, ๋์ด ๋๋ ๊ณต์ ํ๊ณ ์ ํ๋ ๊ธฐํ ๋ฐ์ดํฐ๊ฐ ๋ ์ ์์ต๋๋ค. ๋ํ JSON ํฌ๋งท์ผ๋ก ์์ฑ๋์ด ์ดํดํ๊ธฐ ์ฝ๊ณ ์์
ํ๊ธฐ ์ฝ์ต๋๋ค.
+์๋ช
์ JWT๋ฅผ ์์ ํ๊ฒ ๋ณดํธํ๋ ์ญํ ์ ํฉ๋๋ค. ์๋ช
์ ๋ฐ์ ์๋ง ๋ง๋๋ ๋ฐฉ๋ฒ์ ์๊ณ ์๋ ํน๋ณํ ๋์ฅ๊ณผ ๊ฐ์ต๋๋ค. ์๋ช
์ ๋น๋ฐ๋ฒํธ์ ๊ฐ์ ์ํฌ๋ฆฟ ์ฝ๋๋ฅผ ์ฌ์ฉํ์ฌ ์์ฑ๋ฉ๋๋ค. ์ด ์๋ช
์ ์๋ฌด๋ ๋ฐ์ ์ ๋ชจ๋ฅด๊ฒ JWT์ ๋ด์ฉ์ ๋ณ๊ฒฝํ ์ ์๋๋ก ํฉ๋๋ค.
-When you want to send the JWT to a server, you put the header, payload, and signature inside the box. Then you send it over to the server. The server can easily read the header and payload to understand who you are and what you want to do.
+JWT๋ฅผ ์๋ฒ๋ก ๋ณด๋ด๋ ค๋ฉด ํค๋, ํ์ด๋ก๋, ์๋ช
์ ์์ ์์ ๋ฃ๊ณ ์๋ฒ๋ก ์ ์กํฉ๋๋ค. ์๋ฒ๋ ํค๋์ ํ์ด๋ก๋๋ฅผ ์ฝ๊ฒ ์ฝ๊ณ ์ฌ์ฉ์๊ฐ ๋๊ตฌ์ธ์ง, ๋ฌด์์ ํ๋ ค๋์ง ์ดํดํ ์ ์์ต๋๋ค.
-### How does Google Authenticator (or other types of 2-factor authenticators) work?
+### Google authenticator(๋๋ ๋ค๋ฅธ ์ ํ์ 2 factor authenticator)๋ ์ด๋ป๊ฒ ์๋ํ๋์?
-Google Authenticator is commonly used for logging into our accounts when 2-factor authentication is enabled. How does it guarantee security?
+2๋จ๊ณ ์ธ์ฆ์ด ํ์ฑํ๋ ๊ฒฝ์ฐ ์ผ๋ฐ์ ์ผ๋ก Google ์ธ์ฆ์๊ฐ ๊ณ์ ๋ก๊ทธ์ธ์ ์ฌ์ฉ๋ฉ๋๋ค. ์ด๋ป๊ฒ ๋ณด์์ ๋ณด์ฅํ๋์?
-Google Authenticator is a software-based authenticator that implements a two-step verification service. The diagram below provides detail.
+Google ์ธ์ฆ๊ธฐ๋ 2๋จ๊ณ ์ธ์ฆ ์๋น์ค๋ฅผ ๊ตฌํํ๋ ์ํํธ์จ์ด ๊ธฐ๋ฐ ์ธ์ฆ๊ธฐ์
๋๋ค. ์๋ ๋ค์ด์ด๊ทธ๋จ์์ ์์ธํ ๋ด์ฉ์ ํ์ธํ ์ ์์ต๋๋ค.
-There are two stages involved:
+๋ ์คํ
์ด์ง๊ฐ ์์ต๋๋ค.
-- Stage 1 - The user enables Google two-step verification.
-- Stage 2 - The user uses the authenticator for logging in, etc.
+- ์คํ
์ด์ง 1 - ์ฌ์ฉ์๊ฐ Google 2๋จ๊ณ ์ธ์ฆ์ ํ์ฑํํฉ๋๋ค.
+- ์คํ
์ด์ง 2 - ์ฌ์ฉ์๋ ๋ก๊ทธ์ธ ๋ฑ์ ์ธ์ฆ๊ธฐ๋ฅผ ์ฌ์ฉํฉ๋๋ค.
-Letโs look at these stages.
+์ด ์คํ
์ด์ง๋ฅผ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
-**Stage 1**
+**์คํ
์ด์ง1**
-Steps 1 and 2: Bob opens the web page to enable two-step verification. The front end requests a secret key. The authentication service generates the secret key for Bob and stores it in the database.
+๋จ๊ณ 1,2: Bob์ด ์น ํ์ด์ง๋ฅผ ์ด์ด 2๋จ๊ณ ์ธ์ฆ์ ํ์ฑํํฉ๋๋ค. ํ๋ก ํธ์๋์์ ์ํฌ๋ฆฟ ํค๋ฅผ ์์ฒญํฉ๋๋ค. ์ธ์ฆ ์๋น์ค์์ Bob์ ์ํฌ๋ฆฟ ํค๋ฅผ ์์ฑํ์ฌ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ์ ์ฅํฉ๋๋ค.
-Step 3: The authentication service returns a URI to the front end. The URI is composed of a key issuer, username, and secret key. The URI is displayed in the form of a QR code on the web page.
+๋จ๊ณ 3: ์ธ์ฆ ์๋น์ค๋ ํ๋ก ํธ์๋์ URI๋ฅผ ๋ฐํํฉ๋๋ค. URI๋ ํค ๋ฐ๊ธ์, ์ฌ์ฉ์ ์ด๋ฆ, ์ํฌ๋ฆฟ ํค๋ก ๊ตฌ์ฑ๋ฉ๋๋ค. URI๋ ์น ํ์ด์ง์ QR ์ฝ๋ ํํ๋ก ํ์๋ฉ๋๋ค.
-Step 4: Bob then uses Google Authenticator to scan the generated QR code. The secret key is stored in the authenticator.
+๋จ๊ณ 4: ๊ทธ๋ฐ ๋ค์ Bob์ Google ์ธ์ฆ๊ธฐ๋ฅผ ์ฌ์ฉํ์ฌ ์์ฑ๋ QR ์ฝ๋๋ฅผ ์ค์บํฉ๋๋ค. ์ํฌ๋ฆฟ ํค๋ ์ธ์ฆ๊ธฐ์ ์ ์ฅ๋ฉ๋๋ค.
-**Stage 2**
-Steps 1 and 2: Bob wants to log into a website with Google two-step verification. For this, he needs the password. Every 30 seconds, Google Authenticator generates a 6-digit password using TOTP (Time-based One Time Password) algorithm. Bob uses the password to enter the website.
+**์คํ
์ด์ง2**
+๋จ๊ณ 1, 2: ๋ฐฅ์ ๊ตฌ๊ธ 2๋จ๊ณ ์ธ์ฆ์ผ๋ก ์น์ฌ์ดํธ์ ๋ก๊ทธ์ธํ๋ ค๊ณ ํฉ๋๋ค. ์ด๋ฅผ ์ํด์๋ ๋น๋ฐ๋ฒํธ๊ฐ ํ์ํฉ๋๋ค. Google ์ธ์ฆ๊ธฐ๋ 30์ด๋ง๋ค TOTP(Time-based One Time Password) ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํ์ฌ 6์๋ฆฌ ๋น๋ฐ๋ฒํธ๋ฅผ ์์ฑํฉ๋๋ค. ๋ฐฅ์ ์ด ๋น๋ฐ๋ฒํธ๋ฅผ ์ฌ์ฉํ์ฌ ์น์ฌ์ดํธ์ ๋ค์ด๊ฐ๋๋ค.
-Steps 3 and 4: The frontend sends the password Bob enters to the backend for authentication. The authentication service reads the secret key from the database and generates a 6-digit password using the same TOTP algorithm as the client.
+๋จ๊ณ 3, 4: ํ๋ก ํธ์๋๋ ์ธ์ฆ์ ์ํด ๋ฐฅ์ด ์
๋ ฅํ ๋น๋ฐ๋ฒํธ๋ฅผ ๋ฐฑ์๋๋ก ์ ์กํฉ๋๋ค. ์ธ์ฆ ์๋น์ค๋ ๋ฐ์ดํฐ๋ฒ ์ด์ค์์ ์ํฌ๋ฆฟ ํค๋ฅผ ์ฝ๊ณ ํด๋ผ์ด์ธํธ์ ๋์ผํ TOTP ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํ์ฌ 6์๋ฆฌ ๋น๋ฐ๋ฒํธ๋ฅผ ์์ฑํฉ๋๋ค.
-Step 5: The authentication service compares the two passwords generated by the client and the server, and returns the comparison result to the frontend. Bob can proceed with the login process only if the two passwords match.
+๋จ๊ณ 5: ์ธ์ฆ ์๋น์ค๋ ํด๋ผ์ด์ธํธ์ ์๋ฒ์์ ์์ฑํ ๋ ๊ฐ์ ๋น๋ฐ๋ฒํธ๋ฅผ ๋น๊ตํ๊ณ ๋น๊ต ๊ฒฐ๊ณผ๋ฅผ ํ๋ก ํธ์๋์ ๋ฐํํฉ๋๋ค. Bob์ ๋ ๋น๋ฐ๋ฒํธ๊ฐ ์ผ์นํ๋ ๊ฒฝ์ฐ์๋ง ๋ก๊ทธ์ธ ํ๋ก์ธ์ค๋ฅผ ์งํํ ์ ์์ต๋๋ค.
-Is this authentication mechanism safe?
+์ด ์ธ์ฆ ๋ฉ์ปค๋์ฆ์ ์์ ํ๊ฐ์?
-- Can the secret key be obtained by others?
+- ๋ค๋ฅธ ์ฌ๋์ด ์ํฌ๋ฆฟ ํค๋ฅผ ํ๋ํ ์ ์๋์?
- We need to make sure the secret key is transmitted using HTTPS. The authenticator client and the database store the secret key, and we need to make sure the secret keys are encrypted.
+ ์ํฌ๋ฆฟ ํค๊ฐ HTTPS๋ฅผ ์ฌ์ฉํ์ฌ ์ ์ก๋๋์ง ํ์ธํด์ผ ํฉ๋๋ค. ์ธ์ฆ๊ธฐ ํด๋ผ์ด์ธํธ์ ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ ๋น๋ฐ ํค๋ฅผ ์ ์ฅํ๋ฉฐ, ๋น๋ฐ ํค๊ฐ ์ํธํ๋์ด ์๋์ง ํ์ธํด์ผ ํฉ๋๋ค.
-- Can the 6-digit password be guessed by hackers?
+- ํด์ปค๊ฐ 6์๋ฆฌ ๋น๋ฐ๋ฒํธ๋ฅผ ์ถ์ธกํ ์ ์๋์?
- No. The password has 6 digits, so the generated password has 1 million potential combinations. Plus, the password changes every 30 seconds. If hackers want to guess the password in 30 seconds, they need to enter 30,000 combinations per second.
+ ์๋์. ๋น๋ฐ๋ฒํธ๋ 6์๋ฆฌ๋ก ๊ตฌ์ฑ๋๋ฏ๋ก ์์ฑ๋ ๋น๋ฐ๋ฒํธ์ ์กฐํฉ ๊ฐ๋ฅ ์๋ 100๋ง ๊ฐ์
๋๋ค. ๊ฒ๋ค๊ฐ ๋น๋ฐ๋ฒํธ๋ 30์ด๋ง๋ค ๋ณ๊ฒฝ๋ฉ๋๋ค. ํด์ปค๊ฐ 30์ด ์์ ๋น๋ฐ๋ฒํธ๋ฅผ ์์๋ด๋ ค๋ฉด ์ด๋น 30,000๊ฐ์ ์กฐํฉ์ ์
๋ ฅํด์ผ ํฉ๋๋ค.
## Real World Case Studies
From 0e5533fcb7a4d6dad3296c0c8da4a1a96af524f6 Mon Sep 17 00:00:00 2001
From: kei kim
Date: Wed, 31 Jan 2024 22:17:17 +0900
Subject: [PATCH 13/16] docs: translate to end(real world case)
---
translations/README-kr.md | 228 +++++++++++++++++++-------------------
1 file changed, 114 insertions(+), 114 deletions(-)
diff --git a/translations/README-kr.md b/translations/README-kr.md
index 9c85803..a6e5225 100644
--- a/translations/README-kr.md
+++ b/translations/README-kr.md
@@ -94,16 +94,16 @@
- [๋ฐ์ดํฐ๋ฒ ์ด์ค์ ๋น๋ฐ๋ฒํธ๋ฅผ ์์ ํ๊ฒ ์ ์ฅํ๋ ๋ฐฉ๋ฒ๊ณผ ๋น๋ฐ๋ฒํธ๋ฅผ ํ์ธํ๋ ๋ฐฉ๋ฒ์ ๋ฌด์์ธ๊ฐ์?](#๋ฐ์ดํฐ๋ฒ ์ด์ค์-๋น๋ฐ๋ฒํธ๋ฅผ-์์ ํ๊ฒ-์ ์ฅํ๋-๋ฐฉ๋ฒ๊ณผ-๋น๋ฐ๋ฒํธ๋ฅผ-ํ์ธํ๋-๋ฐฉ๋ฒ์-๋ฌด์์ธ๊ฐ์)
- [10์ธ ์ด๋ฆฐ์ด์๊ฒ JSON Web Token(JWT) ์ค๋ช
ํ๊ธฐ](#10์ธ-์ด๋ฆฐ์ด์๊ฒ-json-web-tokenjwt-์ค๋ช
ํ๊ธฐ)
- [Google authenticator(๋๋ ๋ค๋ฅธ ์ ํ์ 2 factor authenticator)๋ ์ด๋ป๊ฒ ์๋ํ๋์?](#google-authenticator๋๋-๋ค๋ฅธ-์ ํ์-2-factor-authenticator๋-์ด๋ป๊ฒ-์๋ํ๋์)
-- [์ค์ ์ฌ๋ก ์ฐ๊ตฌ](#real-world-case-studies)
- - [๋ทํ๋ฆญ์ค ๊ธฐ์ ์คํ](#netflixs-tech-stack)
- - [ํธ์ํฐ ์ํคํ
์ฒ 2022](#twitter-architecture-2022)
- - [์ง๋ 15๋
๊ฐ ์์ด๋น์ค๋น ๋ง์ดํฌ๋ก์๋น์ค ์ํคํ
์ฒ์ ์งํ ๊ณผ์ ](#evolution-of-airbnbs-microservice-architecture-over-the-past-15-years)
- - [๋ชจ๋
ธ๋ ํฌ vs. ๋ง์ดํฌ๋ก๋ ํฌ](#monorepo-vs-microrepo)
- - [์คํ ์ค๋ฒํ๋ก ์น์ฌ์ดํธ๋ฅผ ์ด๋ป๊ฒ ๋์์ธํ ๊ฑด๊ฐ์?](#how-will-you-design-the-stack-overflow-website)
- - [์๋ง์กด ํ๋ผ์ ๋น๋์ค ๋ชจ๋ํฐ๋ง์ด ์๋ฒ๋ฆฌ์ค์์ ๋ชจ๋๋ฆฌ์์ผ๋ก ์ ํ๋ ์ด์ ๋ ๋ฌด์์ธ๊ฐ์? ์ด๋ป๊ฒ 90%์ ๋น์ฉ์ ์ ๊ฐํ ์ ์์๊น์?](#why-did-amazon-prime-video-monitoring-move-from-serverless-to-monolithic-how-can-it-save-90-cost)
- - [๋์ฆ๋ ํซ์คํ๋ ์ด๋ป๊ฒ ํ ๋๋จผํธ ๊ธฐ๊ฐ ๋์ 50์ต ๊ฐ์ ์ด๋ชจํฐ์ฝ์ ํ๋ํ ์ ์์๋์?](#how-does-disney-hotstar-capture-5-billion-emojis-during-a-tournament)
- - [Discord๊ฐ ์์กฐ ๊ฐ์ ๋ฉ์์ง๋ฅผ ์ ์ฅํ๋ ๋ฐฉ๋ฒ](#how-discord-stores-trillions-of-messages)
- - [๋์์ ๋ผ์ด๋ธ ์คํธ๋ฆฌ๋ฐ์ YouTube, TikTok ๋ผ์ด๋ธ, Twitch์์ ์ด๋ป๊ฒ ์๋ํ๋์?](#how-do-video-live-streamings-work-on-youtube-tiktok-live-or-twitch)
+- [์ค์ ์ฌ๋ก ์ฐ๊ตฌ](#์ค์ -์ฌ๋ก-์ฐ๊ตฌ)
+ - [๋ทํ๋ฆญ์ค ๊ธฐ์ ์คํ](#๋ทํ๋ฆญ์ค-๊ธฐ์ -์คํ)
+ - [ํธ์ํฐ ์ํคํ
์ฒ 2022](#ํธ์ํฐ-์ํคํ
์ฒ-2022)
+ - [์ง๋ 15๋
๊ฐ ์์ด๋น์ค๋น ๋ง์ดํฌ๋ก์๋น์ค ์ํคํ
์ฒ์ ์งํ ๊ณผ์ ](#์ง๋-15๋
๊ฐ-์์ด๋น์ค๋น-๋ง์ดํฌ๋ก์๋น์ค-์ํคํ
์ฒ์-์งํ-๊ณผ์ )
+ - [๋ชจ๋
ธ๋ ํฌ vs. ๋ง์ดํฌ๋ก๋ ํฌ](#๋ชจ๋
ธ๋ ํฌ-vs-๋ง์ดํฌ๋ก๋ ํฌ)
+ - [์คํ ์ค๋ฒํ๋ก ์น์ฌ์ดํธ๋ฅผ ์ด๋ป๊ฒ ๋์์ธํ ๊ฑด๊ฐ์?](#์คํ-์ค๋ฒํ๋ก-์น์ฌ์ดํธ๋ฅผ-์ด๋ป๊ฒ-๋์์ธํ -๊ฑด๊ฐ์)
+ - [์๋ง์กด ํ๋ผ์ ๋น๋์ค ๋ชจ๋ํฐ๋ง์ด ์๋ฒ๋ฆฌ์ค์์ ๋ชจ๋๋ฆฌ์์ผ๋ก ์ ํ๋ ์ด์ ๋ ๋ฌด์์ธ๊ฐ์? ์ด๋ป๊ฒ 90%์ ๋น์ฉ์ ์ ๊ฐํ ์ ์์๊น์?](#์๋ง์กด-ํ๋ผ์-๋น๋์ค-๋ชจ๋ํฐ๋ง์ด-์๋ฒ๋ฆฌ์ค์์-๋ชจ๋๋ฆฌ์์ผ๋ก-์ ํ๋-์ด์ ๋-๋ฌด์์ธ๊ฐ์-์ด๋ป๊ฒ-90์-๋น์ฉ์-์ ๊ฐํ -์-์์๊น์)
+ - [๋์ฆ๋ ํซ์คํ๋ ์ด๋ป๊ฒ ํ ๋๋จผํธ ๊ธฐ๊ฐ ๋์ 50์ต ๊ฐ์ ์ด๋ชจํฐ์ฝ์ ํ๋ํ ์ ์์๋์?](#๋์ฆ๋-ํซ์คํ๋-์ด๋ป๊ฒ-ํ ๋๋จผํธ-๊ธฐ๊ฐ-๋์-50์ต-๊ฐ์-์ด๋ชจํฐ์ฝ์-ํ๋ํ -์-์์๋์)
+ - [Discord๊ฐ ์์กฐ ๊ฐ์ ๋ฉ์์ง๋ฅผ ์ ์ฅํ๋ ๋ฐฉ๋ฒ](#discord๊ฐ-์์กฐ-๊ฐ์-๋ฉ์์ง๋ฅผ-์ ์ฅํ๋-๋ฐฉ๋ฒ)
+ - [๋์์ ๋ผ์ด๋ธ ์คํธ๋ฆฌ๋ฐ์ YouTube, TikTok ๋ผ์ด๋ธ, Twitch์์ ์ด๋ป๊ฒ ์๋ํ๋์?](#๋์์-๋ผ์ด๋ธ-์คํธ๋ฆฌ๋ฐ์-youtube-tiktok-๋ผ์ด๋ธ-twitch์์-์ด๋ป๊ฒ-์๋ํ๋์)
@@ -834,7 +834,7 @@ Redis๋ ๋ค์ด์ด๊ทธ๋จ์ ํ์๋ ๊ฒ์ฒ๋ผ ๋ค์ํ ์๋๋ฆฌ์ค์์ ์ฌ
- Load Balancer: ์ด๋ ๊ฒ ํ๋ฉด ๋ค์ด์ค๋ ํธ๋ํฝ์ด ์ฌ๋ฌ ๋ฐฑ์๋ ์๋น์ค์ ๋ถ์ฐ๋ฉ๋๋ค.
- CDN (Content Delivery Network): CDN์ ๋ ๋น ๋ฅธ ์ ์ก์ ์ํด ์ ์ ์ฝํ
์ธ ๋ฅผ ๋ณด๊ดํ๋ ์ง๋ฆฌ์ ์ผ๋ก ๋ถ์ฐ๋ ์๋ฒ ๊ทธ๋ฃน์
๋๋ค. ํด๋ผ์ด์ธํธ๋ ๋จผ์ CDN์์ ์ฝํ
์ธ ๋ฅผ ์ฐพ์ ๋ค์ ๋ฐฑ์๋ ์๋น์ค๋ก ์ด๋ํฉ๋๋ค.
- API Gateway: ์์ ์์ฒญ์ ์ฒ๋ฆฌํ๊ณ ๊ด๋ จ ์๋น์ค๋ก ๋ผ์ฐํ
ํฉ๋๋ค. ID ๊ณต๊ธ์์ ํต์ ํ๊ณ ์๋น์ค๋ฅผ ๊ฒ์ํฉ๋๋ค.
-- Identity Provider: ์ ์ ์ ๋ํ ์ธ์ฆ๊ณผ ์ธ๊ฐ๋ฅผ ์ฒ๋ฆฌํฉ๋๋ค.
+- Identity Provider: ์ฌ์ฉ์์ ๋ํ ์ธ์ฆ๊ณผ ์ธ๊ฐ๋ฅผ ์ฒ๋ฆฌํฉ๋๋ค.
- Service Registry & Discovery: ์ด ์ปดํฌ๋ํธ์์ ๋ง์ดํฌ๋ก์๋น์ค ๋ฑ๋ก ๋ฐ ๊ฒ์์ด ์ด๋ฃจ์ด์ง๊ณ , API ๊ฒ์ดํธ์จ์ด๋ ์ด ์ปดํฌ๋ํธ์์ ๋ํํ ๊ด๋ จ ์๋น์ค๋ฅผ ์ฐพ์ต๋๋ค.
- Management: ์ด ์ปดํฌ๋ํธ๋ ์๋น์ค ๋ชจ๋ํฐ๋ง์ ๋ด๋นํฉ๋๋ค.
- Microservices: ๋ง์ดํฌ๋ก์๋น์ค๋ ์๋ก ๋ค๋ฅธ ๋๋ฉ์ธ์์ ์ค๊ณ ๋ฐ ๋ฐฐํฌ๋ฉ๋๋ค. ๊ฐ ๋๋ฉ์ธ์๋ ์์ฒด ๋ฐ์ดํฐ๋ฒ ์ด์ค๊ฐ ์์ต๋๋ค. API ๊ฒ์ดํธ์จ์ด๋ REST API ๋๋ ๊ธฐํ ํ๋กํ ์ฝ์ ํตํด ๋ง์ดํฌ๋ก์๋น์ค์ ํต์ ํ๊ณ , ๋์ผํ ๋๋ฉ์ธ ๋ด์ ๋ง์ดํฌ๋ก์๋น์ค๋ RPC(Remote Procedure Call)๋ฅผ ์ฌ์ฉํ์ฌ ์๋ก ํต์ ํฉ๋๋ค.
@@ -1494,62 +1494,62 @@ Google ์ธ์ฆ๊ธฐ๋ 2๋จ๊ณ ์ธ์ฆ ์๋น์ค๋ฅผ ๊ตฌํํ๋ ์ํํธ์จ์ด ๊ธฐ
์๋์. ๋น๋ฐ๋ฒํธ๋ 6์๋ฆฌ๋ก ๊ตฌ์ฑ๋๋ฏ๋ก ์์ฑ๋ ๋น๋ฐ๋ฒํธ์ ์กฐํฉ ๊ฐ๋ฅ ์๋ 100๋ง ๊ฐ์
๋๋ค. ๊ฒ๋ค๊ฐ ๋น๋ฐ๋ฒํธ๋ 30์ด๋ง๋ค ๋ณ๊ฒฝ๋ฉ๋๋ค. ํด์ปค๊ฐ 30์ด ์์ ๋น๋ฐ๋ฒํธ๋ฅผ ์์๋ด๋ ค๋ฉด ์ด๋น 30,000๊ฐ์ ์กฐํฉ์ ์
๋ ฅํด์ผ ํฉ๋๋ค.
-## Real World Case Studies
+## ์ค์ ์ฌ๋ก ์ฐ๊ตฌ
-### Netflix's Tech Stack
+### ๋ทํ๋ฆญ์ค ๊ธฐ์ ์คํ
-This post is based on research from many Netflix engineering blogs and open-source projects. If you come across any inaccuracies, please feel free to inform us.
+์ด ๊ฒ์๋ฌผ์ ์ฌ๋ฌ ๋ทํ๋ฆญ์ค ์์ง๋์ด๋ง ๋ธ๋ก๊ทธ์ ์คํ์์ค ํ๋ก์ ํธ์ ์ฐ๊ตฌ๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ์์ฑ๋์์ต๋๋ค. ๋ถ์ ํํ ๋ด์ฉ์ ๋ฐ๊ฒฌํ๋ฉด ์ธ์ ๋ ์ง ์๋ ค์ฃผ์๊ธฐ ๋ฐ๋๋๋ค.
-**Mobile and web**: Netflix has adopted Swift and Kotlin to build native mobile apps. For its web application, it uses React.
+**Mobile and web**: ๋ทํ๋ฆญ์ค๋ ๋ค์ดํฐ๋ธ ๋ชจ๋ฐ์ผ ์ฑ์ ๊ตฌ์ถํ๊ธฐ ์ํด Swift์ Kotlin์ ์ฑํํ์ต๋๋ค. ์น ์ ํ๋ฆฌ์ผ์ด์
์๋ React๋ฅผ ์ฌ์ฉํฉ๋๋ค.
-**Frontend/server communication**: Netflix uses GraphQL.
+**Frontend/server communication**: ๋ทํ๋ฆญ์ค๋ GraphQL์ ์ฌ์ฉํฉ๋๋ค.
-**Backend services**: Netflix relies on ZUUL, Eureka, the Spring Boot framework, and other technologies.
+**Backend services**: ๋ทํ๋ฆญ์ค๋ ZUUL, ์ ๋ ์นด, ์คํ๋ง ๋ถํธ ํ๋ ์์ํฌ ๋ฐ ๊ธฐํ ๊ธฐ์ ์ ์ฌ์ฉํฉ๋๋ค.
-**Databases**: Netflix utilizes EV cache, Cassandra, CockroachDB, and other databases.
+**Databases**: ๋ทํ๋ฆญ์ค๋ EV ์บ์, ์นด์ฐ๋๋ผ, ์ฝํฌ๋ก์นDB ๋ฐ ๊ธฐํ ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ฅผ ํ์ฉํฉ๋๋ค.
-**Messaging/streaming**: Netflix employs Apache Kafka and Fink for messaging and streaming purposes.
+**Messaging/streaming**: ๋ทํ๋ฆญ์ค๋ ๋ฉ์์ง๊ณผ ์คํธ๋ฆฌ๋ฐ์ ์ํด ์ํ์น ์นดํ์นด์ ํํฌ(Fink)๋ฅผ ์ฌ์ฉํฉ๋๋ค.
-**Video storage**: Netflix uses S3 and Open Connect for video storage.
+**Video storage**: ๋ทํ๋ฆญ์ค๋ ๋น๋์ค ์คํ ๋ฆฌ์ง๋ก S3์ Open Connect๋ฅผ ์ฌ์ฉํฉ๋๋ค.
-**Data processing**: Netflix utilizes Flink and Spark for data processing, which is then visualized using Tableau. Redshift is used for processing structured data warehouse information.
+**Data processing**: ๋ทํ๋ฆญ์ค๋ ๋ฐ์ดํฐ ์ฒ๋ฆฌ๋ฅผ ์ํด Flink์ Spark๋ฅผ ํ์ฉํ๊ณ , ์ด๋ฅผ Tableau๋ฅผ ์ฌ์ฉํ์ฌ ์๊ฐํํฉ๋๋ค. ๊ตฌ์กฐํ๋ ๋ฐ์ดํฐ ์จ์ดํ์ฐ์ค ์ ๋ณด๋ฅผ ์ฒ๋ฆฌํ๋ ๋ฐ๋ Redshift๋ฅผ ์ฌ์ฉํฉ๋๋ค.
-**CI/CD**: Netflix employs various tools such as JIRA, Confluence, PagerDuty, Jenkins, Gradle, Chaos Monkey, Spinnaker, Atlas, and more for CI/CD processes.
+**CI/CD**: ๋ทํ๋ฆญ์ค๋ CI/CD ํ๋ก์ธ์ค๋ฅผ ์ํด JIRA, Confluence, PagerDuty, Jenkins, Gradle, Chaos Monkey, Spinnaker, Atlas ๋ฑ ๋ค์ํ ๋๊ตฌ๋ฅผ ์ฌ์ฉํ๊ณ ์์ต๋๋ค.
-### Twitter Architecture 2022
+### ํธ์ํฐ ์ํคํ
์ฒ 2022
-Yes, this is the real Twitter architecture. It is posted by Elon Musk and redrawn by us for better readability.
+์, ์ด๊ฒ์ด ์ค์ ํธ์ํฐ ์ํคํ
์ฒ์
๋๋ค. ์๋ก ๋จธ์คํฌ๊ฐ ๊ฒ์ํ๊ณ ๊ฐ๋
์ฑ์ ๋์ด๊ธฐ ์ํด ๋ค์ ๊ทธ๋ฆฐ ๊ฒ์
๋๋ค.
-### Evolution of Airbnbโs microservice architecture over the past 15 years
+### ์ง๋ 15๋
๊ฐ ์์ด๋น์ค๋น ๋ง์ดํฌ๋ก์๋น์ค ์ํคํ
์ฒ์ ์งํ ๊ณผ์
-Airbnbโs microservice architecture went through 3 main stages.
+์์ด๋น์ค๋น์ ๋ง์ดํฌ๋ก์๋น์ค ์ํคํ
์ฒ๋ ํฌ๊ฒ 3๊ฐ์ง ์คํ
์ด์ง๋ฅผ ๊ฑฐ์ณค์ต๋๋ค.
-Monolith (2008 - 2017)
+๋ชจ๋๋ฆฌ์ค (2008 - 2017)
-Airbnb began as a simple marketplace for hosts and guests. This is built in a Ruby on Rails application - the monolith.
+์์ด๋น์ค๋น๋ ํธ์คํธ์ ๊ฒ์คํธ๋ฅผ ์ํ ๋จ์ํ ๋ง์ผํ๋ ์ด์ค์์ ์์๋์์ต๋๋ค. ์ด๋ ๋ชจ๋๋ฆฌ์ค๋ผ๊ณ ํ๋ Ruby on Rails ์ ํ๋ฆฌ์ผ์ด์
์ผ๋ก ๊ตฌ์ถ๋์์ต๋๋ค.
-Whatโs the challenge?
+๋์ ๊ณผ์ ๋ ๋ฌด์์ธ๊ฐ์?
-- Confusing team ownership + unowned code
-- Slow deployment
+- ํผ๋์ค๋ฌ์ด ํ ์ค๋์ญ + ์ค๋์ญ ์๋ ์ฝ๋
+- ๋๋ฆฐ ๊ฐ๋ฐ
-Microservices (2017 - 2020)
+๋ง์ดํฌ๋ก์๋น์ค (2017 - 2020)
-Microservice aims to solve those challenges. In the microservice architecture, key services include:
+๋ง์ดํฌ๋ก์๋น์ค๋ ์ด๋ฌํ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ๊ฒ์ ๋ชฉํ๋ก ํฉ๋๋ค. ๋ง์ดํฌ๋ก์๋น์ค ์ํคํ
์ฒ์ ํต์ฌ ์๋น์ค๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค:
- Data fetching service
- Business logic data service
@@ -1557,182 +1557,182 @@ Microservice aims to solve those challenges. In the microservice architecture, k
- UI aggregation service
- Each service had one owning team
-Whatโs the challenge?
+๋์ ๊ณผ์ ๋ ๋ฌด์์ธ๊ฐ์?
-Hundreds of services and dependencies were difficult for humans to manage.
+์๋ฐฑ ๊ฐ์ ์๋น์ค์ ์ข
์์ฑ์ ์ฌ๋์ด ๊ด๋ฆฌํ๊ธฐ ์ด๋ ค์ ์ต๋๋ค.
-Micro + macroservices (2020 - present)
+๋ง์ดํฌ๋ก + ๋งคํฌ๋ก์๋น์ค (2020 - ํ์ฌ)
-This is what Airbnb is working on now. The micro and macroservice hybrid model focuses on the unification of APIs.
+์์ด๋น์ค๋น๋ ํ์ฌ ์ด๋ฅผ ์ํด ๋
ธ๋ ฅํ๊ณ ์์ต๋๋ค. ๋ง์ดํฌ๋ก ๋ฐ ๋งคํฌ๋ก์๋น์ค ํ์ด๋ธ๋ฆฌ๋ ๋ชจ๋ธ์ API ํตํฉ์ ์ค์ ์ ๋ก๋๋ค.
-### Monorepo vs. Microrepo.
+### ๋ชจ๋
ธ๋ ํฌ vs. ๋ง์ดํฌ๋ก๋ ํฌ
-Which is the best? Why do different companies choose different options?
+์ด๋ค ๊ฒ์ด ๊ฐ์ฅ ์ข์๊น์? ํ์ฌ๋ง๋ค ๋ค๋ฅธ ์ต์
์ ์ ํํ๋ ์ด์ ๋ ๋ฌด์์ธ๊ฐ์?
-Monorepo isn't new; Linux and Windows were both created using Monorepo. To improve scalability and build speed, Google developed its internal dedicated toolchain to scale it faster and strict coding quality standards to keep it consistent.
+๋ชจ๋
ธ๋ ํฌ๋ ์๋ก์ด ๊ฒ์ด ์๋๋๋ค. Linux์ Windows ๋ชจ๋ ๋ชจ๋
ธ๋ ํฌ๋ฅผ ์ฌ์ฉํ์ฌ ๋ง๋ค์ด์ก์ต๋๋ค. ํ์ฅ์ฑ๊ณผ ๋น๋ ์๋๋ฅผ ๊ฐ์ ํ๊ธฐ ์ํด Google์ ๋ด๋ถ ์ ์ฉ ํด์ฒด์ธ์ ๊ฐ๋ฐํ์ฌ ๋ ๋น ๋ฅด๊ฒ ํ์ฅํ๊ณ ์๊ฒฉํ ์ฝ๋ฉ ํ์ง ํ์ค์ ์ ์ฉํ์ฌ ์ผ๊ด์ฑ์ ์ ์งํ์ต๋๋ค.
-Amazon and Netflix are major ambassadors of the Microservice philosophy. This approach naturally separates the service code into separate repositories. It scales faster but can lead to governance pain points later on.
+์๋ง์กด๊ณผ ๋ทํ๋ฆญ์ค๋ ๋ง์ดํฌ๋ก์๋น์ค ์ฒ ํ์ ์ฃผ์ ํ๋ณด๋์ฌ์
๋๋ค. ์ด ์ ๊ทผ ๋ฐฉ์์ ์์ฐ์ค๋ฝ๊ฒ ์๋น์ค ์ฝ๋๋ฅผ ๋ณ๋์ ๋ฆฌํฌ์งํ ๋ฆฌ๋ก ๋ถ๋ฆฌํฉ๋๋ค. ํ์ฅ ์๋๋ ๋น ๋ฅด์ง๋ง ๋์ค์ ๊ฑฐ๋ฒ๋์ค ๋ฌธ์ ๊ฐ ๋ฐ์ํ ์ ์์ต๋๋ค.
-Within Monorepo, each service is a folder, and every folder has a BUILD config and OWNERS permission control. Every service member is responsible for their own folder.
+๋ชจ๋
ธ๋ ํฌ ๋ด์์ ๊ฐ ์๋น์ค๋ ํ๋์ ํด๋์ด๋ฉฐ, ๋ชจ๋ ํด๋์๋ ๋น๋ ๊ตฌ์ฑ ๋ฐ ์์ ์ ๊ถํ ์ ์ด๊ฐ ์์ต๋๋ค. ๋ชจ๋ ์๋น์ค ๊ตฌ์ฑ์์ ์์ ์ ํด๋์ ๋ํ ์ฑ
์์ด ์์ต๋๋ค.
-On the other hand, in Microrepo, each service is responsible for its repository, with the build config and permissions typically set for the entire repository.
+๋ฐ๋ฉด Microrepo์์๋ ๊ฐ ์๋น์ค๊ฐ ํด๋น ๋ฆฌํฌ์งํ ๋ฆฌ๋ฅผ ๋ด๋นํ๋ฉฐ, ์ผ๋ฐ์ ์ผ๋ก ์ ์ฒด ๋ฆฌํฌ์งํ ๋ฆฌ์ ๋ํ ๋น๋ ๊ตฌ์ฑ๊ณผ ๊ถํ์ด ์ค์ ๋ฉ๋๋ค.
-In Monorepo, dependencies are shared across the entire codebase regardless of your business, so when there's a version upgrade, every codebase upgrades their version.
+Monorepo์์๋ ๋น์ฆ๋์ค์ ๊ด๊ณ์์ด ์ ์ฒด ์ฝ๋๋ฒ ์ด์ค์์ ์ข
์์ฑ์ด ๊ณต์ ๋๋ฏ๋ก ๋ฒ์ ์
๊ทธ๋ ์ด๋๊ฐ ์์ ๋ ๋ชจ๋ ์ฝ๋๋ฒ ์ด์ค๊ฐ ํด๋น ๋ฒ์ ์ ์
๊ทธ๋ ์ด๋ํฉ๋๋ค.
-In Microrepo, dependencies are controlled within each repository. Businesses choose when to upgrade their versions based on their own schedules.
+Microrepo์์๋ ๊ฐ ๋ฆฌํฌ์งํ ๋ฆฌ ๋ด์์ ์ข
์์ฑ์ ์ ์ดํฉ๋๋ค. ๊ธฐ์
์ ์์ฒด ์ผ์ ์ ๋ฐ๋ผ ๋ฒ์ ์ ์
๊ทธ๋ ์ด๋ํ ์๊ธฐ๋ฅผ ์ ํํ ์ ์์ต๋๋ค.
-Monorepo has a standard for check-ins. Google's code review process is famously known for setting a high bar, ensuring a coherent quality standard for Monorepo, regardless of the business.
+๋ชจ๋
ธ๋ ํฌ์๋ ์ฒดํฌ์ธ์ ๋ํ ํ์ค์ด ์์ต๋๋ค. Google์ ์ฝ๋ ๊ฒํ ํ๋ก์ธ์ค๋ ๋์ ๊ธฐ์ค์ ์ค์ ํ๋ ๊ฒ์ผ๋ก ์ ๋ช
ํ๋ฉฐ, ๋น์ฆ๋์ค์ ๊ด๊ณ์์ด Monorepo์ ์ผ๊ด๋ ํ์ง ํ์ค์ ๋ณด์ฅํฉ๋๋ค.
-Microrepo can either set its own standard or adopt a shared standard by incorporating the best practices. It can scale faster for business, but the code quality might be a bit different.
-Google engineers built Bazel, and Meta built Buck. There are other open-source tools available, including Nx, Lerna, and others.
+Microrepo๋ ์์ฒด ํ์ค์ ์ค์ ํ๊ฑฐ๋ ๋ชจ๋ฒ ์ฌ๋ก๋ฅผ ํตํฉํ์ฌ ๊ณต์ ํ์ค์ ์ฑํํ ์ ์์ต๋๋ค. ๋น์ฆ๋์ค์ ๋ง๊ฒ ๋ ๋น ๋ฅด๊ฒ ํ์ฅํ ์ ์์ง๋ง ์ฝ๋ ํ์ง์ด ์ฝ๊ฐ ๋ค๋ฅผ ์ ์์ต๋๋ค.
+Google ์์ง๋์ด๋ Bazel์, Meta๋ Buck์ ๋ง๋ค์์ต๋๋ค. ๊ทธ ์ธ์๋ Nx, Lerna ๋ฑ ๋ค์ํ ์คํ ์์ค ๋๊ตฌ๊ฐ ์์ต๋๋ค.
-Over the years, Microrepo has had more supported tools, including Maven and Gradle for Java, NPM for NodeJS, and CMake for C/C++, among others.
+์๋
์ ๊ฑธ์ณ Microrepo๋ Java์ฉ Maven๊ณผ Gradle, NodeJS์ฉ NPM, C/C++์ฉ CMake ๋ฑ ๋ ๋ง์ ๋๊ตฌ๋ฅผ ์ง์ํ๊ฒ ๋์์ต๋๋ค.
-### How will you design the Stack Overflow website?
+### ์คํ ์ค๋ฒํ๋ก ์น์ฌ์ดํธ๋ฅผ ์ด๋ป๊ฒ ๋์์ธํ ๊ฑด๊ฐ์?
-If your answer is on-premise servers and monolith (on the bottom of the following image), you would likely fail the interview, but that's how it is built in reality!
+๋ต๋ณ์ด ์จํ๋ ๋ฏธ์ค ์๋ฒ์ ๋ชจ๋๋ฆฌ์ค(๋ค์ ์ด๋ฏธ์ง ํ๋จ)๋ผ๋ฉด ๋ฉด์ ์์ ๋จ์ด์ง ๊ฐ๋ฅ์ฑ์ด ๋์ง๋ง, ์ค์ ๋ก๋ ๊ทธ๋ ๊ฒ ๊ตฌ์ถ๋์ด ์์ต๋๋ค!
-**What people think it should look like**
+**์ฌ๋๋ค์ด ์๊ฐํ๋ ๋์์ธ**
-The interviewer is probably expecting something like the top portion of the picture.
+๋ฉด์ ๊ด์ ์๋ง๋ ์ฌ์ง์ ์๋จ ๋ถ๋ถ๊ณผ ๊ฐ์ ๊ฒ์ ๊ธฐ๋ํ๊ณ ์์ ๊ฒ์
๋๋ค.
-- Microservice is used to decompose the system into small components.
-- Each service has its own database. Use cache heavily.
-- The service is sharded.
-- The services talk to each other asynchronously through message queues.
-- The service is implemented using Event Sourcing with CQRS.
-- Showing off knowledge in distributed systems such as eventual consistency, CAP theorem, etc.
+- ๋ง์ดํฌ๋ก์๋น์ค๋ ์์คํ
์ ์์ ์ปดํฌ๋ํธ๋ก ๋ถํดํ๋ ๋ฐ ์ฌ์ฉ๋ฉ๋๋ค.
+- ๊ฐ ์๋น์ค์๋ ์์ฒด ๋ฐ์ดํฐ๋ฒ ์ด์ค๊ฐ ์์ต๋๋ค. ์บ์๋ฅผ ๋ง์ด ์ฌ์ฉํ์ธ์.
+- ์๋น์ค๊ฐ ์ค๋ฉ๋ฉ๋๋ค.
+- ์๋น์ค๋ ๋ฉ์์ง ํ๋ฅผ ํตํด ๋น๋๊ธฐ์ ์ผ๋ก ์๋ก ํต์ ํฉ๋๋ค.
+- ์ด ์๋น์ค๋ ์ด๋ฒคํธ ์์ฑ๊ณผ CQRS๋ฅผ ์ฌ์ฉํ์ฌ ๊ตฌํ๋ฉ๋๋ค.
+- ์ต์ข
์ ํฉ์ฑ, CAP ์ ๋ฆฌ ๋ฑ๊ณผ ๊ฐ์ ๋ถ์ฐ ์์คํ
์ ๋ํ ์ง์์ ๋ฝ๋ด ๋ณด์ธ์.
-**What it actually is**
+**์ค์ ๋ด์ฉ**
-Stack Overflow serves all the traffic with only 9 on-premise web servers, and itโs on monolith! It has its own servers and does not run on the cloud.
+์คํ ์ค๋ฒํ๋ก๋ ๋จ 9๋์ ์จํ๋ ๋ฏธ์ค ์น ์๋ฒ๋ก ๋ชจ๋ ํธ๋ํฝ์ ์ฒ๋ฆฌํ๋ฉฐ, ์ด ์๋ฒ๋ ๋ชจ๋๋ฆฌ์ค๋ก ์ด์๋ฉ๋๋ค! ์์ฒด ์๋ฒ๋ฅผ ๋ณด์ ํ๊ณ ์์ผ๋ฉฐ ํด๋ผ์ฐ๋์์ ์คํ๋์ง ์์ต๋๋ค.
-This is contrary to all our popular beliefs these days.
+์ด๋ ์ค๋๋ ์ ์ผ๋ฐ์ ์ธ ๋ฏฟ์๊ณผ๋ ์๋ฐ๋๋ ๊ฒ์
๋๋ค.
-### Why did Amazon Prime Video monitoring move from serverless to monolithic? How can it save 90% cost?
+### ์๋ง์กด ํ๋ผ์ ๋น๋์ค ๋ชจ๋ํฐ๋ง์ด ์๋ฒ๋ฆฌ์ค์์ ๋ชจ๋๋ฆฌ์์ผ๋ก ์ ํ๋ ์ด์ ๋ ๋ฌด์์ธ๊ฐ์? ์ด๋ป๊ฒ 90%์ ๋น์ฉ์ ์ ๊ฐํ ์ ์์๊น์?
-The diagram below shows the architecture comparison before and after the migration.
+์๋ ๋ค์ด์ด๊ทธ๋จ์ ๋ง์ด๊ทธ๋ ์ด์
์ ๊ณผ ํ์ ์ํคํ
์ฒ๋ฅผ ๋น๊ตํ ๊ฒ์
๋๋ค.
-What is Amazon Prime Video Monitoring Service?
+Amazon ํ๋ผ์ ๋น๋์ค ๋ชจ๋ํฐ๋ง ์๋น์ค๋ ๋ฌด์์ธ๊ฐ์?
-Prime Video service needs to monitor the quality of thousands of live streams. The monitoring tool automatically analyzes the streams in real time and identifies quality issues like block corruption, video freeze, and sync problems. This is an important process for customer satisfaction.
+ํ๋ผ์ ๋น๋์ค ์๋น์ค๋ ์์ฒ ๊ฐ์ ๋ผ์ด๋ธ ์คํธ๋ฆผ์ ํ์ง์ ๋ชจ๋ํฐ๋งํด์ผ ํฉ๋๋ค. ๋ชจ๋ํฐ๋ง ๋๊ตฌ๋ ์ค์๊ฐ์ผ๋ก ์คํธ๋ฆผ์ ์๋์ผ๋ก ๋ถ์ํ๊ณ ๋ธ๋ก ์์, ๋์์ ์ ์ง, ๋๊ธฐํ ๋ฌธ์ ์ ๊ฐ์ ํ์ง ๋ฌธ์ ๋ฅผ ์๋ณํฉ๋๋ค. ์ด๋ ๊ณ ๊ฐ ๋ง์กฑ์ ์ํ ์ค์ํ ํ๋ก์ธ์ค์
๋๋ค.
-There are 3 steps: media converter, defect detector, and real-time notification.
+๋ฏธ๋์ด ์ปจ๋ฒํฐ, ๊ฒฐํจ ๊ฒ์ถ๊ธฐ, ์ค์๊ฐ ์๋ฆผ์ 3๋จ๊ณ๋ก ๊ตฌ์ฑ๋ฉ๋๋ค.
-- What is the problem with the old architecture?
+- ๊ธฐ์กด ์ํคํ
์ฒ์ ๋ฌธ์ ์ ์ ๋ฌด์์ธ๊ฐ์?
- The old architecture was based on Amazon Lambda, which was good for building services quickly. However, it was not cost-effective when running the architecture at a high scale. The two most expensive operations are:
+ ์ด์ ์ํคํ
์ฒ๋ Amazon Lambda๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํ์ฌ ์๋น์ค๋ฅผ ๋น ๋ฅด๊ฒ ๊ตฌ์ถํ๋ ๋ฐ๋ ์ข์์ต๋๋ค. ํ์ง๋ง ๋๊ท๋ชจ๋ก ์ํคํ
์ฒ๋ฅผ ์คํํ ๋๋ ๋น์ฉ ํจ์จ์ ์ด์ง ์์์ต๋๋ค. ๋ค์์ ๊ฐ์ฅ ๋น์ฉ์ด ๋ง์ด ๋๋ ๋ ๊ฐ์ง ์์
์
๋๋ค.
-1. The orchestration workflow - AWS step functions charge users by state transitions and the orchestration performs multiple state transitions every second.
+1. ์ค์ผ์คํธ๋ ์ด์
์ํฌํ๋ก - AWS ์คํ
ํจ์๋ ์ํ ์ ํ๋ณ๋ก ์ฌ์ฉ์์๊ฒ ์๊ธ์ ๋ถ๊ณผํ๊ณ , ์ค์ผ์คํธ๋ ์ด์
์ ๋งค์ด๋ง๋ค ์ฌ๋ฌ ์ํ ์ ํ์ ์ํํฉ๋๋ค.
-2. Data passing between distributed components - the intermediate data is stored in Amazon S3 so that the next stage can download. The download can be costly when the volume is high.
+2. ๋ถ์ฐ๋ ์ปดํฌ๋ํธ ๊ฐ์ ๋ฐ์ดํฐ ์ ๋ฌ - ์ธํฐ๋ฏธ๋์ดํธ ๋ฐ์ดํฐ๋ ๋ค์ ์คํ
์ด์ง์ ๋ค์ด๋ก๋๋ฅผ ์ํด Amazon S3์ ์ ์ฅ๋ฉ๋๋ค. ๋ณผ๋ฅจ์ด ํฌ๋ฉด ๋ค์ด๋ก๋ ๋น์ฉ์ด ๋ง์ด ๋ค ์ ์์ต๋๋ค.
-- Monolithic architecture saves 90% cost
+- ๋ชจ๋๋ฆฌ์ ์ํคํ
์ฒ๋ก 90% ๋น์ฉ ์ ๊ฐ
- A monolithic architecture is designed to address the cost issues. There are still 3 components, but the media converter and defect detector are deployed in the same process, saving the cost of passing data over the network. Surprisingly, this approach to deployment architecture change led to 90% cost savings!
+ ๋ชจ๋๋ฆฌ์ ์ํคํ
์ฒ๋ ๋น์ฉ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด ์ค๊ณ๋์์ต๋๋ค. ์ฌ์ ํ 3๊ฐ์ ์ปดํฌ๋ํธ๊ฐ ์์ง๋ง ๋ฏธ๋์ด ์ปจ๋ฒํฐ์ ๊ฒฐํจ ๊ฐ์ง๊ธฐ๊ฐ ๋์ผํ ํ๋ก์ธ์ค์ ๋ฐฐํฌ๋์ด ๋คํธ์ํฌ๋ฅผ ํตํ ๋ฐ์ดํฐ ์ ๋ฌ ๋น์ฉ์ ์ ๊ฐํ ์ ์์ต๋๋ค. ๋๋๊ฒ๋ ์ด๋ฌํ ๋ฐฐํฌ ์ํคํ
์ฒ ๋ณ๊ฒฝ ๋ฐฉ์์ 90%์ ๋น์ฉ ์ ๊ฐ ํจ๊ณผ๋ฅผ ๊ฐ์ ธ์์ต๋๋ค!
-This is an interesting and unique case study because microservices have become a go-to and fashionable choice in the tech industry. It's good to see that we are having more discussions about evolving the architecture and having more honest discussions about its pros and cons. Decomposing components into distributed microservices comes with a cost.
+๋ง์ดํฌ๋ก์๋น์ค๊ฐ ๊ธฐ์ ์
๊ณ์์ ์ ํ์ฒ๋ผ ๋ฒ์ง๊ณ ์๋ ๋งํผ ์ด ์ฌ๋ก๋ ํฅ๋ฏธ๋กญ๊ณ ๋
ํนํ ์ฌ๋ก ์ฐ๊ตฌ์
๋๋ค. ์ํคํ
์ฒ์ ์งํ์ ๋ํด ๋ ๋ง์ ๋
ผ์๋ฅผ ํ๊ณ ์ฅ๋จ์ ์ ๋ํด ๋ ์์งํ ํ ๋ก ์ ํ๊ณ ์๋ค๋ ๊ฒ์ ์ข์ ์ผ์
๋๋ค. ์ปดํฌ๋ํธ๋ฅผ ๋ถ์ฐํ ๋ง์ดํฌ๋ก์๋น์ค๋ก ๋ถํดํ๋ ๋ฐ์๋ ๋น์ฉ์ด ๋ฐ์ํฉ๋๋ค.
-- What did Amazon leaders say about this?
+- ์ด์ ๋ํด ์๋ง์กด์ ๋ฆฌ๋๋ค์ ์ด๋ค ๋ฐ์์ ๋ณด์์๊น์?
- Amazon CTO Werner Vogels: โBuilding **evolvable software systems** is a strategy, not a religion. And revisiting your architecture with an open mind is a must.โ
+ ์๋ง์กด CTO Werner Vogels: "**์งํ ๊ฐ๋ฅํ ์ํํธ์จ์ด ์์คํ
**์ ๊ตฌ์ถํ๋ ๊ฒ์ ์ ๋ต์ด์ง ์ข
๊ต๊ฐ ์๋๋๋ค. ๊ทธ๋ฆฌ๊ณ ์ด๋ฆฐ ๋ง์์ผ๋ก ์ํคํ
์ฒ๋ฅผ ์ฌ๊ฒํ ํ๋ ๊ฒ์ ํ์์
๋๋ค."
-Ex Amazon VP Sustainability Adrian Cockcroft: โThe Prime Video team had followed a path I call **Serverless First**โฆI donโt advocate **Serverless Only**โ.
+Ex Amazon VP Sustainability Adrian Cockcroft: "ํ๋ผ์ ๋น๋์ค ํ์ ์ ๊ฐ **์๋ฒ๋ฆฌ์ค ํผ์คํธ**๋ผ๊ณ ๋ถ๋ฅด๋ ๊ธธ์ ๋ฐ๋์ต๋๋ค. ์ ๋ **์๋ฒ๋ฆฌ์ค ์จ๋ฆฌ**๋ฅผ ์นํธํ์ง ์์ต๋๋ค.".
-### How does Disney Hotstar capture 5 Billion Emojis during a tournament?
+### ๋์ฆ๋ ํซ์คํ๋ ์ด๋ป๊ฒ ํ ๋๋จผํธ ๊ธฐ๊ฐ ๋์ 50์ต ๊ฐ์ ์ด๋ชจํฐ์ฝ์ ํ๋ํ ์ ์์๋์?
-1. Clients send emojis through standard HTTP requests. You can think of Golang Service as a typical Web Server. Golang is chosen because it supports concurrency well. Threads in Golang are lightweight.
+1. ํด๋ผ์ด์ธํธ๋ ํ์ค HTTP ์์ฒญ์ ํตํด ์ด๋ชจํฐ์ฝ์ ์ ์กํฉ๋๋ค. ๊ณ ๋ญ ์๋น์ค๋ ์ผ๋ฐ์ ์ธ ์น ์๋ฒ๋ผ๊ณ ์๊ฐํ๋ฉด ๋ฉ๋๋ค. ๊ณ ๋ญ์ ์ ํํ ์ด์ ๋ ๋์์ฑ์ ์ ์ง์ํ๊ธฐ ๋๋ฌธ์
๋๋ค. ๊ณ ๋ญ์ ์ค๋ ๋๋ ๊ฐ๋ณ์ต๋๋ค.
-2. Since the write volume is very high, Kafka (message queue) is used as a buffer.
+2. ์ฐ๊ธฐ ๋ณผ๋ฅจ์ด ๋งค์ฐ ๋๊ธฐ ๋๋ฌธ์ Kafka(๋ฉ์์ง ํ)๊ฐ ๋ฒํผ๋ก ์ฌ์ฉ๋ฉ๋๋ค.
-3. Emoji data are aggregated by a streaming processing service called Spark. It aggregates data every 2 seconds, which is configurable. There is a trade-off to be made based on the interval. A shorter interval means emojis are delivered to other clients faster but it also means more computing resources are needed.
+3. ์ด๋ชจํฐ์ฝ ๋ฐ์ดํฐ๋ Spark๋ผ๋ ์คํธ๋ฆฌ๋ฐ ์ฒ๋ฆฌ ์๋น์ค์ ์ํด ์ด๊ทธ๋ฆฌ๊ฒ์ดํธ๋ฉ๋๋ค. ์ด ์๋น์ค๋ 2์ด๋ง๋ค ๋ฐ์ดํฐ๋ฅผ ์ด๊ทธ๋ฆฌ๊ฒ์ดํธํ๋ฉฐ, ๊ทธ ์ฃผ๊ธฐ๋ ์ค์ ํ ์ ์์ต๋๋ค. ๊ฐ๊ฒฉ์ ๋ฐ๋ผ ํธ๋ ์ด๋์คํ๊ฐ ์์ต๋๋ค. ๊ฐ๊ฒฉ์ด ์งง์์๋ก ๋ค๋ฅธ ํด๋ผ์ด์ธํธ์ ์ด๋ชจํฐ์ฝ์ด ๋ ๋นจ๋ฆฌ ์ ๋ฌ๋์ง๋ง ๋ ๋ง์ ์ปดํจํ
๋ฆฌ์์ค๊ฐ ํ์ํ๋ค๋ ์๋ฏธ๋ ๋ฉ๋๋ค.
-4. Aggregated data is written to another Kafka.
+4. ์ด๊ทธ๋ฆฌ๊ฒ์ดํธ๋ ๋ฐ์ดํฐ๋ ๋ ๋ค๋ฅธ ์นดํ์นด์ ๊ธฐ๋ก๋ฉ๋๋ค.
-5. The PubSub consumers pull aggregated emoji data from Kafka.
+5. PubSub ์ปจ์๋จธ๋ ์นดํ์นด์์ ์ด๊ทธ๋ฆฌ๊ฒ์ดํธ๋ ์ด๋ชจํฐ์ฝ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ ธ์ต๋๋ค.
-6. Emojis are delivered to other clients in real-time through the PubSub infrastructure. The PubSub infrastructure is interesting. Hotstar considered the following protocols: Socketio, NATS, MQTT, and gRPC, and settled with MQTT.
+6. ์ด๋ชจํฐ์ฝ์ PubSub ์ธํ๋ผ๋ฅผ ํตํด ๋ค๋ฅธ ํด๋ผ์ด์ธํธ์๊ฒ ์ค์๊ฐ์ผ๋ก ์ ๋ฌ๋ฉ๋๋ค. PubSub ์ธํ๋ผ๋ ํฅ๋ฏธ๋กญ์ต๋๋ค. ํซ์คํ๋ ๋ค์๊ณผ ๊ฐ์ ํ๋กํ ์ฝ์ ๊ณ ๋ คํ์ต๋๋ค. Socketio, NATS, MQTT, gRPC๋ฅผ ๊ฒํ ํ ๊ฒฐ๊ณผ MQTT๋ก ๊ฒฐ์ ํ์ต๋๋ค.
-A similar design is adopted by LinkedIn which streams a million likes/sec.
+์ด๋น ๋ฐฑ๋ง ๊ฐ์ '์ข์์'๋ฅผ ์คํธ๋ฆฌ๋ฐํ๋ LinkedIn์์๋ ๋น์ทํ ๋์์ธ์ ์ฑํํ๊ณ ์์ต๋๋ค.
-### How Discord Stores Trillions Of Messages
+### Discord๊ฐ ์์กฐ ๊ฐ์ ๋ฉ์์ง๋ฅผ ์ ์ฅํ๋ ๋ฐฉ๋ฒ
-The diagram below shows the evolution of message storage at Discord:
+์๋ ๋ค์ด์ด๊ทธ๋จ์ Discord์์ ๋ฉ์์ง ์คํ ๋ฆฌ์ง์ ์งํ ๊ณผ์ ์ ๋ณด์ฌ์ค๋๋ค:
-MongoDB โก๏ธ Cassandra โก๏ธ ScyllaDB
+๋ชฝ๊ณ DB โก๏ธ ์นด์ฐ๋๋ผ โก๏ธ ์ค๋ผDB
-In 2015, the first version of Discord was built on top of a single MongoDB replica. Around Nov 2015, MongoDB stored 100 million messages and the RAM couldnโt hold the data and index any longer. The latency became unpredictable. Message storage needs to be moved to another database. Cassandra was chosen.
+2015๋
, Discord์ ์ฒซ ๋ฒ์งธ ๋ฒ์ ์ ๋จ์ผ MongoDB ๋ ํ๋ฆฌ์นด ์์ ๊ตฌ์ถ๋์์ต๋๋ค. 2015๋
11์๊ฒฝ, MongoDB์ 1์ต ๊ฐ์ ๋ฉ์์ง๊ฐ ์ ์ฅ๋์ RAM์ด ๋ ์ด์ ๋ฐ์ดํฐ์ ์์ธ์ ์ ์ฅํ ์ ์๊ฒ ๋์์ต๋๋ค. ์ง์ฐ ์๊ฐ์ ์์ธกํ ์ ์๊ฒ ๋์์ต๋๋ค. ๋ฉ์์ง ์ ์ฅ์๋ฅผ ๋ค๋ฅธ ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ก ์ฎ๊ฒจ์ผ ํ์ต๋๋ค. ์นด์ฐ๋๋ผ๊ฐ ์ ํ๋์์ต๋๋ค.
-In 2017, Discord had 12 Cassandra nodes and stored billions of messages.
+2017๋
, Discord์๋ 12๊ฐ์ ์นด์ฐ๋๋ผ ๋
ธ๋๊ฐ ์์๊ณ ์์ญ์ต ๊ฐ์ ๋ฉ์์ง๊ฐ ์ ์ฅ๋์ด ์์์ต๋๋ค.
-At the beginning of 2022, it had 177 nodes with trillions of messages. At this point, latency was unpredictable, and maintenance operations became too expensive to run.
+2022๋
์ด์๋ 177๊ฐ์ ๋
ธ๋์ ์์กฐ ๊ฐ์ ๋ฉ์์ง๊ฐ ์์์ต๋๋ค. ์ด ์์ ์์๋ ์ง์ฐ ์๊ฐ์ ์์ธกํ ์ ์์๊ณ ์ ์ง๋ณด์ ์ด์ ๋น์ฉ์ด ๋๋ฌด ๋ง์ด ๋ค์์ต๋๋ค.
-There are several reasons for the issue:
+์ฌ๊ธฐ์๋ ๋ช ๊ฐ์ง ์ด์ ๊ฐ ์์ต๋๋ค.
-- Cassandra uses the LSM tree for the internal data structure. The reads are more expensive than the writes. There can be many concurrent reads on a server with hundreds of users, resulting in hotspots.
-- Maintaining clusters, such as compacting SSTables, impacts performance.
-- Garbage collection pauses would cause significant latency spikes
+- Cassandra๋ ๋ด๋ถ ๋ฐ์ดํฐ ๊ตฌ์กฐ์ LSM ํธ๋ฆฌ๋ฅผ ์ฌ์ฉํฉ๋๋ค. ์ฝ๊ธฐ๋ ์ฐ๊ธฐ๋ณด๋ค ๋น์ฉ์ด ๋ ๋ง์ด ๋ญ๋๋ค. ์๋ฐฑ ๋ช
์ ์ฌ์ฉ์๊ฐ ์๋ ์๋ฒ์์ ๋์ ์ฝ๊ธฐ๊ฐ ๋ง์ด ๋ฐ์ํ์ฌ ํซ์คํ์ด ๋ฐ์ํ ์ ์์ต๋๋ค.
+- SSTable์ ์์ถํ๋ ๋ฑ ํด๋ฌ์คํฐ๋ฅผ ์ ์ง ๊ด๋ฆฌํ๋ฉด ์ฑ๋ฅ์ ์ํฅ์ ๋ฏธ์นฉ๋๋ค.
+- ๊ฐ๋น์ง ์ปฌ๋ ์
์ผ์ ์ค์ง๋ก ์ธํด ์ง์ฐ ์๊ฐ์ด ํฌ๊ฒ ์ฆ๊ฐํฉ๋๋ค.
-ScyllaDB is Cassandra compatible database written in C++. Discord redesigned its architecture to have a monolithic API, a data service written in Rust, and ScyllaDB-based storage.
+ScyllaDB๋ C++๋ก ์์ฑ๋ ์นด์ฐ๋๋ผ ํธํ ๋ฐ์ดํฐ๋ฒ ์ด์ค์
๋๋ค. Discord๋ ๋ชจ๋๋ฆฌ์ API, Rust๋ก ์์ฑ๋ ๋ฐ์ดํฐ ์๋น์ค, ScyllaDB ๊ธฐ๋ฐ ์คํ ๋ฆฌ์ง๋ฅผ ๊ฐ์ถ๋๋ก ์ํคํ
์ฒ๋ฅผ ์ฌ์ค๊ณํ์ต๋๋ค.
-The p99 read latency in ScyllaDB is 15ms compared to 40-125ms in Cassandra. The p99 write latency is 5ms compared to 5-70ms in Cassandra.
+ScyllaDB์ p99 ์ฝ๊ธฐ ์ง์ฐ ์๊ฐ์ 15ms์ธ ๋ฐ๋ฉด Cassandra๋ 40-125ms์
๋๋ค. p99 ์ฐ๊ธฐ ์ง์ฐ ์๊ฐ์ 5ms์ธ๋ฐ ๋ฐํด Cassandra๋ 5-70ms์
๋๋ค.
-### How do video live streamings work on YouTube, TikTok live, or Twitch?
-
-Live streaming differs from regular streaming because the video content is sent via the internet in real-time, usually with a latency of just a few seconds.
-
-The diagram below explains what happens behind the scenes to make this possible.
+### ๋์์ ๋ผ์ด๋ธ ์คํธ๋ฆฌ๋ฐ์ YouTube, TikTok ๋ผ์ด๋ธ, Twitch์์ ์ด๋ป๊ฒ ์๋ํ๋์?
+
+๋ผ์ด๋ธ ์คํธ๋ฆฌ๋ฐ์ ๋น๋์ค ์ฝํ
์ธ ๊ฐ ์ธํฐ๋ท์ ํตํด ์ค์๊ฐ์ผ๋ก ์ ์ก๋๋ฉฐ ์ผ๋ฐ์ ์ผ๋ก ๋ช ์ด์ ์ง์ฐ ์๊ฐ๋ง ๋ฐ์ํ๋ค๋ ์ ์์ ์ผ๋ฐ ์คํธ๋ฆฌ๋ฐ๊ณผ ๋ค๋ฆ
๋๋ค.
+
+์๋ ๋ค์ด์ด๊ทธ๋จ์ ์ด๋ฌํ ์์
์ ๊ฐ๋ฅํ๊ฒ ํ๊ธฐ ์ํด ์ค์ ๋ก ๋ฌด์จ ์ผ์ด ๋ฐ์ํ๋์ง ์ค๋ช
ํฉ๋๋ค.
-Step 1: The raw video data is captured by a microphone and camera. The data is sent to the server side.
+1๋จ๊ณ: ๋ก์ฐ ๋น๋์ค ๋ฐ์ดํฐ๋ ๋ง์ดํฌ์ ์นด๋ฉ๋ผ๋ก ์บก์ฒ๋ฉ๋๋ค. ๋ฐ์ดํฐ๋ ์๋ฒ ์ธก์ผ๋ก ์ ์ก๋ฉ๋๋ค.
-Step 2: The video data is compressed and encoded. For example, the compressing algorithm separates the background and other video elements. After compression, the video is encoded to standards such as H.264. The size of the video data is much smaller after this step.
+2๋จ๊ณ: ๋์์ ๋ฐ์ดํฐ๋ ์์ถํ๊ณ ์ธ์ฝ๋ฉ๋ฉ๋๋ค. ์๋ฅผ ๋ค์ด, ์์ถ ์๊ณ ๋ฆฌ์ฆ์ ๋ฐฐ๊ฒฝ๊ณผ ๊ธฐํ ๋น๋์ค ์์๋ฅผ ๋ถ๋ฆฌํฉ๋๋ค. ์์ถ ํ ๋์์์ H.264์ ๊ฐ์ ํ์ค์ผ๋ก ์ธ์ฝ๋ฉ๋ฉ๋๋ค. ์ด ๋จ๊ณ๋ฅผ ๊ฑฐ์น๋ฉด ๋์์ ๋ฐ์ดํฐ์ ํฌ๊ธฐ๊ฐ ํจ์ฌ ์์์ง๋๋ค.
-Step 3: The encoded data is divided into smaller segments, usually seconds in length, so it takes much less time to download or stream.
+3๋จ๊ณ: ์ธ์ฝ๋ฉ๋ ๋ฐ์ดํฐ๋ ๋ณดํต ๋ช ์ด ๊ธธ์ด์ ์์ ์ธ๊ทธ๋จผํธ๋ก ๋๋๊ธฐ ๋๋ฌธ์ ๋ค์ด๋ก๋๋ ์คํธ๋ฆฌ๋ฐ์ ๊ฑธ๋ฆฌ๋ ์๊ฐ์ ํจ์ฌ ์งง์ต๋๋ค.
-Step 4: The segmented data is sent to the streaming server. The streaming server needs to support different devices and network conditions. This is called โAdaptive Bitrate Streaming.โ This means we need to produce multiple files at different bitrates in steps 2 and 3.
+4๋จ๊ณ: ์ธ๊ทธ๋จผํธํ๋ ๋ฐ์ดํฐ๋ ์คํธ๋ฆฌ๋ฐ ์๋ฒ๋ก ์ ์ก๋ฉ๋๋ค. ์คํธ๋ฆฌ๋ฐ ์๋ฒ๋ ๋ค์ํ ๋๋ฐ์ด์ค์ ๋คํธ์ํฌ ์กฐ๊ฑด์ ์ง์ํด์ผ ํฉ๋๋ค. ์ด๋ฅผ 'โAdaptive Bitrate Streaming'์ด๋ผ๊ณ ํฉ๋๋ค. ์ฆ, 2๋จ๊ณ์ 3๋จ๊ณ์์ ์๋ก ๋ค๋ฅธ ๋นํธ๋ ์ดํธ๋ก ์ฌ๋ฌ ๊ฐ์ ํ์ผ์ ์์ฑํด์ผ ํฉ๋๋ค.
-Step 5: The live streaming data is pushed to edge servers supported by CDN (Content Delivery Network.) Millions of viewers can watch the video from an edge server nearby. CDN significantly lowers data transmission latency.
+5๋จ๊ณ: ๋ผ์ด๋ธ ์คํธ๋ฆฌ๋ฐ ๋ฐ์ดํฐ๋ CDN(Content Delivery Network)์ด ์ง์ํ๋ ์ฃ์ง ์๋ฒ๋ก ํธ์๋๋ฉฐ, ์๋ฐฑ๋ง ๋ช
์ ์์ฒญ์๊ฐ ๊ฐ๊น์ด ์ฃ์ง ์๋ฒ์์ ๋์์์ ์์ฒญํ ์ ์์ต๋๋ค. CDN์ ๋ฐ์ดํฐ ์ ์ก ์ง์ฐ ์๊ฐ์ ํฌ๊ฒ ์ค์ฌ์ค๋๋ค.
-Step 6: The viewersโ devices decode and decompress the video data and play the video in a video player.
+6๋จ๊ณ: ์์ฒญ์์ ๋๋ฐ์ด์ค๋ ๋์์ ๋ฐ์ดํฐ๋ฅผ ๋์ฝ๋ฉ ๋ฐ ์์ถ ํด์ ํ๊ณ ๋์์ ํ๋ ์ด์ด์์ ๋์์์ ์ฌ์ํฉ๋๋ค.
-Steps 7 and 8: If the video needs to be stored for replay, the encoded data is sent to a storage server, and viewers can request a replay from it later.
+7, 8๋จ๊ณ: ๋์์์ ๋ค์ ๋ณด๊ธฐ ์ํด ์ ์ฅํด์ผ ํ๋ ๊ฒฝ์ฐ ์ธ์ฝ๋ฉ๋ ๋ฐ์ดํฐ๋ ์คํ ๋ฆฌ์ง ์๋ฒ๋ก ์ ์ก๋๋ฉฐ, ์์ฒญ์๋ ๋์ค์ ๋ค์ ๋ณด๊ธฐ๋ฅผ ์์ฒญํ ์ ์์ต๋๋ค.
-Standard protocols for live streaming include:
+๋ผ์ด๋ธ ์คํธ๋ฆฌ๋ฐ์ ์ํ ํ์ค ํ๋กํ ์ฝ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
-- RTMP (Real-Time Messaging Protocol): This was originally developed by Macromedia to transmit data between a Flash player and a server. Now it is used for streaming video data over the internet. Note that video conferencing applications like Skype use RTC (Real-Time Communication) protocol for lower latency.
-- HLS (HTTP Live Streaming): It requires the H.264 or H.265 encoding. Apple devices accept only HLS format.
-- DASH (Dynamic Adaptive Streaming over HTTP): DASH does not support Apple devices.
-- Both HLS and DASH support adaptive bitrate streaming.
+- RTMP (Real-Time Messaging Protocol): ์๋๋ Macromedia์์ ํ๋์ ํ๋ ์ด์ด์ ์๋ฒ ๊ฐ์ ๋ฐ์ดํฐ๋ฅผ ์ ์กํ๊ธฐ ์ํด ๊ฐ๋ฐํ์ต๋๋ค. ์ง๊ธ์ ์ธํฐ๋ท์ ํตํ ๋น๋์ค ๋ฐ์ดํฐ ์คํธ๋ฆฌ๋ฐ์ ์ฌ์ฉ๋ฉ๋๋ค. Skype์ ๊ฐ์ ํ์ ํ์ ์ ํ๋ฆฌ์ผ์ด์
์ ์ง์ฐ ์๊ฐ์ ์ค์ด๊ธฐ ์ํด RTC(Real-Time Communication) ํ๋กํ ์ฝ์ ์ฌ์ฉํ๋ค๋ ์ ์ ์ ์ํ์ธ์.
+- HLS (HTTP Live Streaming): H.264 ๋๋ H.265 ์ธ์ฝ๋ฉ์ด ํ์ํฉ๋๋ค. Apple ์ฅ์น๋ HLS ํฌ๋งท๋ง ํ์ฉํฉ๋๋ค.
+- DASH (Dynamic Adaptive Streaming over HTTP): DASH๋ Apple ์ฅ์น๋ฅผ ์ง์ํ์ง ์์ต๋๋ค.
+- HLS์ DASH๋ ๋ชจ๋ ์ด๋ํฐ๋ธ ๋นํธ๋ ์ดํธ ์คํธ๋ฆฌ๋ฐ์ ์ง์ํฉ๋๋ค.
## License
From c1ee72f83cd35e59192455dc010dfedc67ce5c54 Mon Sep 17 00:00:00 2001
From: Deadintegral
Date: Wed, 31 Jan 2024 22:38:45 +0900
Subject: [PATCH 14/16] docs: translate missing parts
---
translations/README-kr.md | 90 +++++++++++++++++++--------------------
1 file changed, 45 insertions(+), 45 deletions(-)
diff --git a/translations/README-kr.md b/translations/README-kr.md
index a6e5225..a64f6c2 100644
--- a/translations/README-kr.md
+++ b/translations/README-kr.md
@@ -20,21 +20,21 @@
์์คํ
๋์์ธ ๋ฉด์ ์ ์ค๋น ์ค์ด๊ฑฐ๋ ๋จ์ํ ์์คํ
์ด ํ๋ฉด ์๋์์ ์ด๋ป๊ฒ ์๋ํ๋์ง ์ดํดํ๊ณ ์ถ์ผ์ ๋ถ์ด๋ผ๋ฉด ์ด ๋ฆฌํฌ์งํ ๋ฆฌ๊ฐ ๋์์ด ๋๊ธธ ๋ฐ๋๋๋ค.
-# Table of Contents
+# ๋ชฉ์ฐจ
- [Communication protocols](#communication-protocols)
- - [REST API vs. GraphQL](#rest-api-vs-graphql)
+ - [REST API vs GraphQL](#rest-api-vs-graphql)
- [gRPC๋ ์ด๋ป๊ฒ ์๋ํ๋์?](#grpc๋-์ด๋ป๊ฒ-์๋ํ๋์)
- - [webhook์ด๋ ๋ฌด์์ธ๊ฐ์?](#what-is-a-webhook)
+ - [webhook์ด๋ ๋ฌด์์ธ๊ฐ์?](#webhook์ด๋-๋ฌด์์ธ๊ฐ์)
- [API ์ฑ๋ฅ์ ๊ฐ์ ํ๋ ๋ฐฉ๋ฒ์ ๋ฌด์์ธ๊ฐ์?](#api-์ฑ๋ฅ์-๊ฐ์ ํ๋-๋ฐฉ๋ฒ์-๋ฌด์์ธ๊ฐ์)
- [HTTP 1.0 -\> HTTP 1.1 -\> HTTP 2.0 -\> HTTP 3.0 (QUIC)](#http-10---http-11---http-20---http-30-quic)
- [SOAP vs REST vs GraphQL vs RPC](#soap-vs-rest-vs-graphql-vs-rpc)
- - [Code First vs. API First](#code-first-vs-api-first)
+ - [Code First vs API First](#code-first-vs-api-first)
- [HTTP status codes](#http-status-codes)
- - [API gateway๋ ๋ฌด์์ ํ๋์?](#what-does-api-gateway-do)
- - [ํจ๊ณผ์ ์ด๊ณ ์์ ํ API๋ฅผ ์ค๊ณํ๋ ค๋ฉด ์ด๋ป๊ฒ ํด์ผ ํ ๊น์?](#how-do-we-design-effective-and-safe-apis)
+ - [API gateway๋ ๋ฌด์์ ํ๋์?](#api-gateway๋-๋ฌด์์-ํ๋์)
+ - [ํจ๊ณผ์ ์ด๊ณ ์์ ํ API๋ฅผ ์ค๊ณํ๋ ค๋ฉด ์ด๋ป๊ฒ ํด์ผ ํ ๊น์?](#ํจ๊ณผ์ ์ด๊ณ -์์ ํ-api๋ฅผ-์ค๊ณํ๋ ค๋ฉด-์ด๋ป๊ฒ-ํด์ผ-ํ ๊น์)
- [TCP/IP encapsulation](#tcpip-encapsulation)
- [์ Nginx๋ฅผ "reverse" ํ๋ก์๋ผ๊ณ ๋ถ๋ฅด๋์?](#์-nginx๋ฅผ-reverse-ํ๋ก์๋ผ๊ณ -๋ถ๋ฅด๋์)
- [์ผ๋ฐ์ ์ธ ๋ก๋ ๋ฐธ๋ฐ์ฑ ์๊ณ ๋ฆฌ์ฆ์ ๋ฌด์์ธ๊ฐ์?](#์ผ๋ฐ์ ์ธ-๋ก๋-๋ฐธ๋ฐ์ฑ-์๊ณ ๋ฆฌ์ฆ์-๋ฌด์์ธ๊ฐ์)
@@ -44,8 +44,8 @@
- [๋ทํ๋ฆญ์ค ๊ธฐ์ ์คํ (CI/CD Pipeline)](#๋ทํ๋ฆญ์ค-๊ธฐ์ ์คํ-cicd-pipeline)
- [์ํคํ
์ฒ ํจํด](#์ํคํ
์ฒ-ํจํด)
- [MVC, MVP, MVVM, MVVM-C, VIPER](#mvc-mvp-mvvm-mvvm-c-and-viper)
- - [18 Key Design Patterns Every Developer Should Know](#18-key-design-patterns-every-developer-should-know)
-- [Database](#database)
+ - [๋ชจ๋ ๊ฐ๋ฐ์๊ฐ ์์์ผ ํ 18๊ฐ์ง ํต์ฌ ๋์์ธ ํจํด](#๋ชจ๋ -๊ฐ๋ฐ์๊ฐ-์์์ผ-ํ -18๊ฐ์ง-ํต์ฌ-๋์์ธ-ํจํด)
+- [๋ฐ์ดํฐ๋ฒ ์ด์ค](#๋ฐ์ดํฐ๋ฒ ์ด์ค)
- [ํด๋ผ์ฐ๋ ์๋น์ค์ ๋ค์ํ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ๊ดํ ์นํธ์ํธ](#ํด๋ผ์ฐ๋-์๋น์ค์-๋ค์ํ-๋ฐ์ดํฐ๋ฒ ์ด์ค์-๊ดํ-์นํธ์ํธ)
- [๋ฐ์ดํฐ๋ฒ ์ด์ค๋ฅผ ๊ฐํํ๋ 8๊ฐ์ง ๋ฐ์ดํฐ ๊ตฌ์กฐ](#๋ฐ์ดํฐ๋ฒ ์ด์ค๋ฅผ-๊ฐํํ๋-8๊ฐ์ง-๋ฐ์ดํฐ-๊ตฌ์กฐ)
- [๋ฐ์ดํฐ๋ฒ ์ด์ค์์ SQL ๋ฌธ์ ์ด๋ป๊ฒ ์คํ๋๋์?](#๋ฐ์ดํฐ๋ฒ ์ด์ค์์-SQL-๋ฌธ์-์ด๋ป๊ฒ-์คํ๋๋์)
@@ -69,14 +69,14 @@
- [์์ ์์ ์ฐ๋ฆฌ๊ฐ ์ ์ฉ์นด๋๋ฅผ ๊ธ์ ๋, VISA๋ ์ด๋ป๊ฒ ์๋ํ๋์?](#์์ ์์-์ฐ๋ฆฌ๊ฐ-์ ์ฉ์นด๋๋ฅผ-๊ธ์-๋-visa๋-์ด๋ป๊ฒ-์๋ํ๋์)
- [์ธ๊ณ์ ๊ฒฐ์ ์์คํ
์๋ฆฌ์ฆ(1๋ถ): ์ธ๋์ ํตํฉ ๊ฒฐ์ ์ธํฐํ์ด์ค(UPI)](#์ธ๊ณ์-๊ฒฐ์ -์์คํ
-์๋ฆฌ์ฆ1๋ถ-์ธ๋์-ํตํฉ-๊ฒฐ์ -์ธํฐํ์ด์คupi)
- [DevOps](#devops)
- - [DevOps vs. SRE vs. Platform Engineering. ๋ฌด์์ด ๋ค๋ฅธ๊ฐ์?](#devops-vs-sre-vs-platform-engineering-what-is-the-difference)
+ - [DevOps vs SRE vs Platform Engineering ๋ฌด์์ด ๋ค๋ฅธ๊ฐ์?](#devops-vs-sre-vs-platform-engineering-๋ฌด์์ด-๋ค๋ฅธ๊ฐ์)
- [k8s(Kubernetes)๋ ๋ฌด์์ธ๊ฐ์?](#k8skubernetes๋-๋ฌด์์ธ๊ฐ์)
- - [Docker vs. Kubernetes. ์ด๋ค๊ฒ์ ์ฌ์ฉํด์ผ ํ๋์?](#docker-vs-kubernetes-์ด๋ค๊ฒ์-์ฌ์ฉํด์ผ-ํ๋์)
+ - [Docker vs Kubernetes. ์ด๋ค๊ฒ์ ์ฌ์ฉํด์ผ ํ๋์?](#docker-vs-kubernetes-์ด๋ค๊ฒ์-์ฌ์ฉํด์ผ-ํ๋์)
- [Docker๋ ์ด๋ป๊ฒ ์๋ํ๋์?](#docker๋-์ด๋ป๊ฒ-์๋ํ๋์)
- [GIT](#git)
- [Git Commands ์๋ ๋ฐฉ์](#git-commands-์๋-๋ฐฉ์)
- [Git์ ์ด๋ป๊ฒ ์๋ํ๋์?](#git์-์ด๋ป๊ฒ-์๋ํ๋์)
- - [Git merge vs. Git rebase](#git-merge-vs-git-rebase)
+ - [Git merge vs Git rebase](#git-merge-vs-git-rebase)
- [ํด๋ผ์ฐ๋ ์๋น์ค](#ํด๋ผ์ฐ๋-์๋น์ค)
- [๋ค์ํ ํด๋ผ์ฐ๋ ์๋น์ค์ ๋ํ ์ ์ฉํ ์นํธ์ํธ(2023๋
ํ)](#๋ค์ํ-ํด๋ผ์ฐ๋-์๋น์ค์-๋ํ-์ ์ฉํ-์นํธ์ํธ2023๋
ํ)
- [cloud native๋ ๋ฌด์์ธ๊ฐ์?](#cloud-native๋-๋ฌด์์ธ๊ฐ์)
@@ -98,7 +98,7 @@
- [๋ทํ๋ฆญ์ค ๊ธฐ์ ์คํ](#๋ทํ๋ฆญ์ค-๊ธฐ์ -์คํ)
- [ํธ์ํฐ ์ํคํ
์ฒ 2022](#ํธ์ํฐ-์ํคํ
์ฒ-2022)
- [์ง๋ 15๋
๊ฐ ์์ด๋น์ค๋น ๋ง์ดํฌ๋ก์๋น์ค ์ํคํ
์ฒ์ ์งํ ๊ณผ์ ](#์ง๋-15๋
๊ฐ-์์ด๋น์ค๋น-๋ง์ดํฌ๋ก์๋น์ค-์ํคํ
์ฒ์-์งํ-๊ณผ์ )
- - [๋ชจ๋
ธ๋ ํฌ vs. ๋ง์ดํฌ๋ก๋ ํฌ](#๋ชจ๋
ธ๋ ํฌ-vs-๋ง์ดํฌ๋ก๋ ํฌ)
+ - [๋ชจ๋
ธ๋ ํฌ vs ๋ง์ดํฌ๋ก๋ ํฌ](#๋ชจ๋
ธ๋ ํฌ-vs-๋ง์ดํฌ๋ก๋ ํฌ)
- [์คํ ์ค๋ฒํ๋ก ์น์ฌ์ดํธ๋ฅผ ์ด๋ป๊ฒ ๋์์ธํ ๊ฑด๊ฐ์?](#์คํ-์ค๋ฒํ๋ก-์น์ฌ์ดํธ๋ฅผ-์ด๋ป๊ฒ-๋์์ธํ -๊ฑด๊ฐ์)
- [์๋ง์กด ํ๋ผ์ ๋น๋์ค ๋ชจ๋ํฐ๋ง์ด ์๋ฒ๋ฆฌ์ค์์ ๋ชจ๋๋ฆฌ์์ผ๋ก ์ ํ๋ ์ด์ ๋ ๋ฌด์์ธ๊ฐ์? ์ด๋ป๊ฒ 90%์ ๋น์ฉ์ ์ ๊ฐํ ์ ์์๊น์?](#์๋ง์กด-ํ๋ผ์-๋น๋์ค-๋ชจ๋ํฐ๋ง์ด-์๋ฒ๋ฆฌ์ค์์-๋ชจ๋๋ฆฌ์์ผ๋ก-์ ํ๋-์ด์ ๋-๋ฌด์์ธ๊ฐ์-์ด๋ป๊ฒ-90์-๋น์ฉ์-์ ๊ฐํ -์-์์๊น์)
- [๋์ฆ๋ ํซ์คํ๋ ์ด๋ป๊ฒ ํ ๋๋จผํธ ๊ธฐ๊ฐ ๋์ 50์ต ๊ฐ์ ์ด๋ชจํฐ์ฝ์ ํ๋ํ ์ ์์๋์?](#๋์ฆ๋-ํซ์คํ๋-์ด๋ป๊ฒ-ํ ๋๋จผํธ-๊ธฐ๊ฐ-๋์-50์ต-๊ฐ์-์ด๋ชจํฐ์ฝ์-ํ๋ํ -์-์์๋์)
@@ -152,7 +152,7 @@
์ด๋ฒคํธ๊ฐ ๋ฐ์ํ๋ฉด ์์คํ
์ ์๋ฆผ
-### REST API vs. GraphQL
+### REST API vs GraphQL
API ์ค๊ณ์ ์์ด์ REST์ GraphQL์ ๊ณ ์ ์ ์ฅ๋จ์ ์ด ์์ต๋๋ค.
@@ -205,7 +205,7 @@ RPC(Remote Procedure Call)๋ ๋ง์ดํฌ๋ก์๋น์ค ์ํคํ
์ฒ์์ ์๋น์ค
12-14๋จ๊ณ: ์ฃผ๋ฌธ ์๋น์ค๊ฐ ํจํท์ ์์ ํ์ฌ ๋์ฝ๋ฉํ ํ ๊ฒฐ๊ณผ๋ฅผ ํด๋ผ์ด์ธํธ ์ ํ๋ฆฌ์ผ์ด์
์ ๋ณด๋
๋๋ค.
-### What is a webhook?
+### webhook์ด๋ ๋ฌด์์ธ๊ฐ์?
์๋ ๋ค์ด์ด๊ทธ๋จ์ ํด๋ง๊ณผ ์นํ
์ ๋น๊ตํ ๊ฒ์
๋๋ค.
@@ -304,7 +304,7 @@ QUIC์ UDP๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํฉ๋๋ค. ์ด๋ ์ ์ก ๊ณ์ธต์์ ์คํธ๋ฆผ์
-### Code First vs. API First
+### Code First vs API First
์๋ ๋ค์ด์ด๊ทธ๋จ์ ์ฝ๋ ํผ์คํธ ๊ฐ๋ฐ๊ณผ API ํผ์คํธ ๊ฐ๋ฐ์ ์ฐจ์ด์ ์ ๋ณด์ฌ์ค๋๋ค. API ํผ์คํธ ์ค๊ณ๋ฅผ ๊ณ ๋ คํด์ผ ํ๋ ์ด์ ๋ ๋ฌด์์ธ๊ฐ์?
@@ -344,7 +344,7 @@ Redirection (300-399)
Client Error (400-499)
Server Error (500-599)
-### What does API gateway do?
+### API gateway๋ ๋ฌด์์ ํ๋์?
์๋ ๋ค์ด์ด๊ทธ๋จ์ ์์ธํ ๋ด์ฉ์ ๋ณด์ฌ์ค๋๋ค.
@@ -368,7 +368,7 @@ Server Error (500-599)
9-12๋จ๊ณ: API ๊ฒ์ดํธ์จ์ด๋ ์ค๋ฅ๋ฅผ ์ ์ ํ๊ฒ ์ฒ๋ฆฌํ๊ณ , ๋ณต๊ตฌํ๋ ๋ฐ ์๊ฐ์ด ์ค๋ ๊ฑธ๋ฆฌ๋ ์ค๋ฅ๊ฐ ๋ฐ์ํ๋ ๊ฒฝ์ฐ ์ฅ์ ๋ฅผ ์ฒ๋ฆฌํฉ๋๋ค.(circuit break) ๋ํ ๋ก๊น
๊ณผ ๋ชจ๋ํฐ๋ง์ ์ํด ELK(Elastic-Logstash-Kibana) ์คํ์ ํ์ฉํ ์ ์์ต๋๋ค. ๋๋๋ก API ๊ฒ์ดํธ์จ์ด์ ๋ฐ์ดํฐ๋ฅผ ์บ์ํ๊ธฐ๋ ํฉ๋๋ค.
-### How do we design effective and safe APIs?
+### ํจ๊ณผ์ ์ด๊ณ ์์ ํ API๋ฅผ ์ค๊ณํ๋ ค๋ฉด ์ด๋ป๊ฒ ํด์ผ ํ ๊น์?
์๋ ๋ค์ด์ด๊ทธ๋จ์ ์ผํ ์นดํธ ์์์ ํจ๊ป ์ผ๋ฐ์ ์ธ API ์ค๊ณ๋ฅผ ๋ณด์ฌ์ค๋๋ค.
@@ -556,7 +556,7 @@ Continuous Delivery(CD)๋ ์ธํ๋ผ ๋ณ๊ฒฝ, ๋ฐฐํฌ์ ๊ฐ์ ๋ฆด๋ฆฌ์ค ํ๋ก
- ๋๋ถ๋ถ์ ํจํด์๋ ๋น์ฆ๋์ค ๋ฐ์ดํฐ๋ฅผ ๊ด๋ฆฌํ๊ธฐ ์ํ 'model'(M)์ด ํฌํจ๋ฉ๋๋ค.
- "Controller", " presenter", "view-model"์ ๋ทฐ์ ๋ชจ๋ธ(VIPER ํจํด์ "entity") ์ฌ์ด๋ฅผ ๋งค๊ฐํ๋ ๋ณํ๊ธฐ์
๋๋ค.
-### 18 Key Design Patterns Every Developer Should Know
+### ๋ชจ๋ ๊ฐ๋ฐ์๊ฐ ์์์ผ ํ 18๊ฐ์ง ํต์ฌ ๋์์ธ ํจํด
ํจํด์ ์ผ๋ฐ์ ์ธ ์ค๊ณ ๋ฌธ์ ์ ๋ํ ์ฌ์ฌ์ฉ ๊ฐ๋ฅํ ์๋ฃจ์
์ผ๋ก, ๋ณด๋ค ์ํํ๊ณ ํจ์จ์ ์ธ ๊ฐ๋ฐ ํ๋ก์ธ์ค๋ฅผ ๊ฐ๋ฅํ๊ฒ ํฉ๋๋ค. ํจํด์ ๋ ๋์ ์ํํธ์จ์ด ๊ตฌ์กฐ๋ฅผ ๊ตฌ์ถํ๊ธฐ ์ํ ์ฒญ์ฌ์ง ์ญํ ์ ํฉ๋๋ค. ๋ค์์ ๊ฐ์ฅ ๋ง์ด ์ฌ์ฉ๋๋ ํจํด ์ค ์ผ๋ถ์
๋๋ค.
@@ -564,26 +564,26 @@ Continuous Delivery(CD)๋ ์ธํ๋ผ ๋ณ๊ฒฝ, ๋ฐฐํฌ์ ๊ฐ์ ๋ฆด๋ฆฌ์ค ํ๋ก
-- Abstract Factory: Family Creator - Makes groups of related items.
-- Builder: Lego Master - Builds objects step by step, keeping creation and appearance separate.
-- Prototype: Clone Maker - Creates copies of fully prepared examples.
-- Singleton: One and Only - A special class with just one instance.
-- Adapter: Universal Plug - Connects things with different interfaces.
-- Bridge: Function Connector - Links how an object works to what it does.
-- Composite: Tree Builder - Forms tree-like structures of simple and complex parts.
-- Decorator: Customizer - Adds features to objects without changing their core.
-- Facade: One-Stop-Shop - Represents a whole system with a single, simplified interface.
-- Flyweight: Space Saver - Shares small, reusable items efficiently.
-- Proxy: Stand-In Actor - Represents another object, controlling access or actions.
-- Chain of Responsibility: Request Relay - Passes a request through a chain of objects until handled.
-- Command: Task Wrapper - Turns a request into an object, ready for action.
-- Iterator: Collection Explorer - Accesses elements in a collection one by one.
-- Mediator: Communication Hub - Simplifies interactions between different classes.
-- Memento: Time Capsule - Captures and restores an object's state.
-- Observer: News Broadcaster - Notifies classes about changes in other objects.
-- Visitor: Skillful Guest - Adds new operations to a class without altering it.
-
-## Database
+- Abstract Factory: Family Creator - ๊ด๋ จ ํญ๋ชฉ ๊ทธ๋ฃน์ ๋ง๋ญ๋๋ค.
+- Builder: Lego Master - ์์ฑ ๋ฐ ๋ชจ์์ ๋ถ๋ฆฌํ์ฌ ๊ฐ์ฒด๋ฅผ ๋จ๊ณ๋ณ๋ก ๋น๋ํฉ๋๋ค.
+- Prototype: Clone Maker - ์์ ํ ์ค๋น๋ ์์ ์ ๋ณต์ฌ๋ณธ์ ์์ฑํฉ๋๋ค.
+- Singleton: One and Only - ์ธ์คํด์ค๊ฐ ํ๋๋ฟ์ธ ํน๋ณํ ํด๋์ค์
๋๋ค.
+- Adapter: Universal Plug - ์๋ก ๋ค๋ฅธ ์ธํฐํ์ด์ค๋ฅผ ๊ฐ์ง ๊ฒ๋ค์ ์ฐ๊ฒฐํฉ๋๋ค.
+- Bridge: Function Connector - ๊ฐ์ฒด์ ๊ตฌํ๊ณผ ํ๋์ ์ฐ๊ฒฐํฉ๋๋ค.
+- Composite: Tree Builder - ๋จ์ํ ๋ถ๋ถ๊ณผ ๋ณต์กํ ๋ถ๋ถ์ผ๋ก ์ด๋ฃจ์ด์ง ํธ๋ฆฌ ๊ตฌ์กฐ๋ฅผ ํ์ฑํฉ๋๋ค.
+- Decorator: Customizer - ๊ฐ์ฒด์ ํต์ฌ์ ์์ํ์ง ์๊ณ ๊ธฐ๋ฅ์ ์ถ๊ฐํฉ๋๋ค.
+- Facade: One-Stop-Shop - ์ ์ฒด ์์คํ
์ ๋จ์ผํ๊ณ ๊ฐ๋จํ ์ธํฐํ์ด์ค๋ก ๋ํ๋
๋๋ค.
+- Flyweight: Space Saver - ์๊ณ ์ฌ์ฌ์ฉ ๊ฐ๋ฅํ ํญ๋ชฉ์ ํจ์จ์ ์ผ๋ก ๊ณต์ ํฉ๋๋ค.
+- Proxy: Stand-In Actor - ๋ค๋ฅธ ๊ฐ์ฒด๋ฅผ ๋ํํ์ฌ ์ก์ธ์ค ๋๋ ์์
์ ์ ์ดํฉ๋๋ค.
+- Chain of Responsibility: Request Relay - ์์ฒญ์ ์ฒ๋ฆฌํ ๋๊น์ง ๊ฐ์ฒด ์ฒด์ธ์ ํตํด ์ ๋ฌํฉ๋๋ค.
+- Command: Task Wrapper - ์์ฒญ์ ๊ฐ์ฒด๋ก ๋ณํํ์ฌ ์์
์ค๋น๋ฅผ ๊ฐ์ถ๊ฒ ํฉ๋๋ค.
+- Iterator: Collection Explorer - ์ปฌ๋ ์
์ ์์์ ํ๋์ฉ ์ก์ธ์คํฉ๋๋ค.
+- Mediator: Communication Hub - ์๋ก ๋ค๋ฅธ ํด๋์ค ๊ฐ์ ์ธํฐ๋์
์ ๊ฐ์ํํฉ๋๋ค.
+- Memento: Time Capsule - ๊ฐ์ฒด์ ์ํ๋ฅผ ์บก์ฒํ๊ณ ๋ณต์ํฉ๋๋ค.
+- Observer: News Broadcaster - ๋ค๋ฅธ ๊ฐ์ฒด์ ๋ณ๊ฒฝ์ ๋ํด ํด๋์ค์๊ฒ ์๋ฆฝ๋๋ค.
+- Visitor: Skillful Guest - ๊ฐ์ฒด๋ฅผ ๋ณ๊ฒฝํ์ง ์๊ณ ์๋ก์ด ์์
์ ์ถ๊ฐํฉ๋๋ค.
+
+## ๋ฐ์ดํฐ๋ฒ ์ด์ค
### ํด๋ผ์ฐ๋ ์๋น์ค์ ๋ค์ํ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ๊ดํ ์นํธ์ํธ
@@ -591,11 +591,11 @@ Continuous Delivery(CD)๋ ์ธํ๋ผ ๋ณ๊ฒฝ, ๋ฐฐํฌ์ ๊ฐ์ ๋ฆด๋ฆฌ์ค ํ๋ก
-ํ๋ก์ ํธ์ ์ ํฉํ ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ฅผ ์ ํํ๋ ๊ฒ์ ๋ณต์กํ ์์
์
๋๋ค. ๊ฐ๊ธฐ ๋ค๋ฅธ ์ ์ฆ์ผ์ด์ค์ ์ ํฉํ ๋ฐ์ดํฐ๋ฒ ์ด์ค ์ต์
์ด ๋ง์ผ๋ฉด ์์ฌ ๊ฒฐ์ ์ ๋ํ ํผ๋ก๋๊ฐ ๋น ๋ฅด๊ฒ ๋์์ง ์ ์์ต๋๋ค.
+ํ๋ก์ ํธ์ ์ ํฉํ ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ฅผ ์ ํํ๋ ๊ฒ์ ๋ณต์กํ ์์
์
๋๋ค. ๊ฐ๊ธฐ ๋ค๋ฅธ ์ ์ฆ์ผ์ด์ค์ ์ ํฉํ ๋ฐ์ดํฐ๋ฒ ์ด์ค ์ต์
์ด ๋ง์ผ๋ฉด ์์ฌ ๊ฒฐ์ ์ ๋ํ ํผ๋ก๋๊ฐ ๋น ๋ฅด๊ฒ ๋์์ง ์ ์์ต๋๋ค.
-์ด ์นํธ์ํธ๊ฐ ํ๋ก์ ํธ์ ์๊ตฌ์ฌํญ์ ๋ง๋ ์ฌ๋ฐ๋ฅธ ์๋น์ค๋ฅผ ์ฐพ์๋ด๊ณ ์ ์ฌ์ ์ธ ํจ์ ์ ํผํ๋ ๋ฐ ๋์์ด ๋๊ธฐ๋ฅผ ๋ฐ๋๋๋ค.
+์ด ์นํธ์ํธ๊ฐ ํ๋ก์ ํธ์ ์๊ตฌ์ฌํญ์ ๋ง๋ ์ฌ๋ฐ๋ฅธ ์๋น์ค๋ฅผ ์ฐพ์๋ด๊ณ ์ ์ฌ์ ์ธ ํจ์ ์ ํผํ๋ ๋ฐ ๋์์ด ๋๊ธฐ๋ฅผ ๋ฐ๋๋๋ค.
-์ฐธ๊ณ : Google์ ๋ฐ์ดํฐ๋ฒ ์ด์ค ์ ์ฆ์ผ์ด์ค์ ๋ํ ๋ฌธ์๊ฐ ์ ํ๋์ด ์์ต๋๋ค. ์ฌ์ฉ ๊ฐ๋ฅํ ์๋ฃ๋ฅผ ์ต๋ํ ๊ฒํ ํ๊ณ ์ต์ ์ ์ต์
์ ์ ์ํ์ง๋ง, ์ผ๋ถ ํญ๋ชฉ์ ๋ ์ ํํ ์ ๋ณด๊ฐ ํ์ํ ์ ์์ต๋๋ค.
+์ฐธ๊ณ : Google์ ๋ฐ์ดํฐ๋ฒ ์ด์ค ์ ์ฆ์ผ์ด์ค์ ๋ํ ๋ฌธ์๊ฐ ์ ํ๋์ด ์์ต๋๋ค. ์ฌ์ฉ ๊ฐ๋ฅํ ์๋ฃ๋ฅผ ์ต๋ํ ๊ฒํ ํ๊ณ ์ต์ ์ ์ต์
์ ์ ์ํ์ง๋ง, ์ผ๋ถ ํญ๋ชฉ์ ๋ ์ ํํ ์ ๋ณด๊ฐ ํ์ํ ์ ์์ต๋๋ค.
### ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ฅผ ๊ฐํํ๋ 8๊ฐ์ง ๋ฐ์ดํฐ ๊ตฌ์กฐ
@@ -1014,7 +1014,7 @@ UPI = ๊ฒฐ์ ๋งํฌ์
์ธ์ด + ์ํธ ์ด์ฉ ๊ฐ๋ฅํ ๊ฒฐ์ ํ์ค
## DevOps
-### DevOps vs. SRE vs. Platform Engineering. What is the difference?
+### DevOps vs SRE vs Platform Engineering ๋ฌด์์ด ๋ค๋ฅธ๊ฐ์?
๋ฐ๋ธ์ต์ค, SRE, ํ๋ซํผ ์์ง๋์ด๋ง์ ๊ฐ๋
์ ์๋ก ๋ค๋ฅธ ์๊ธฐ์ ๋ฑ์ฅํ์ฌ ๋ค์ํ ๊ฐ์ธ๊ณผ ์กฐ์ง์ ์ํด ๋ฐ์ ํด ์์ต๋๋ค.
@@ -1074,7 +1074,7 @@ k8s ํด๋ฌ์คํฐ๋ ์ปจํ
์ด๋ํ๋ ์ ํ๋ฆฌ์ผ์ด์
์ ์คํํ๋ ๋
ธ๋
Kube-proxy๋ ํด๋ฌ์คํฐ์ ๊ฐ ๋
ธ๋์์ ์คํ๋๋ ๋คํธ์ํฌ ํ๋ก์์
๋๋ค. ์๋น์ค์์ ๋
ธ๋๋ก ๋ค์ด์ค๋ ํธ๋ํฝ์ ๋ผ์ฐํ
ํฉ๋๋ค. ์์
์์ฒญ์ ์ฌ๋ฐ๋ฅธ ์ปจํ
์ด๋๋ก ์ ๋ฌํฉ๋๋ค.
-### Docker vs. Kubernetes. ์ด๋ค๊ฒ์ ์ฌ์ฉํด์ผ ํ๋์?
+### Docker vs Kubernetes ์ด๋ค๊ฒ์ ์ฌ์ฉํด์ผ ํ๋์?
@@ -1164,7 +1164,7 @@ Git์ ๋ถ์ฐ ๋ฒ์ ๊ด๋ฆฌ ์์คํ
์
๋๋ค.
๋ฆฌ๋ชจํธ ๋ฆฌํฌ์งํ ๋ฆฌ์ ์ถฉ๋์ด ๋ฐ์ํ๋ฉด ๋ก์ปฌ ๋ฆฌํฌ์งํ ๋ฆฌ์์ ํ์ผ์ ๋ณต๊ตฌํ ์ ์์ต๋๋ค.
-### Git merge vs. Git rebase
+### Git merge vs Git rebase
์ด๋ค ์ ์ด ๋ค๋ฅธ๊ฐ์?
@@ -1565,7 +1565,7 @@ Google ์ธ์ฆ๊ธฐ๋ 2๋จ๊ณ ์ธ์ฆ ์๋น์ค๋ฅผ ๊ตฌํํ๋ ์ํํธ์จ์ด ๊ธฐ
์์ด๋น์ค๋น๋ ํ์ฌ ์ด๋ฅผ ์ํด ๋
ธ๋ ฅํ๊ณ ์์ต๋๋ค. ๋ง์ดํฌ๋ก ๋ฐ ๋งคํฌ๋ก์๋น์ค ํ์ด๋ธ๋ฆฌ๋ ๋ชจ๋ธ์ API ํตํฉ์ ์ค์ ์ ๋ก๋๋ค.
-### ๋ชจ๋
ธ๋ ํฌ vs. ๋ง์ดํฌ๋ก๋ ํฌ
+### ๋ชจ๋
ธ๋ ํฌ vs ๋ง์ดํฌ๋ก๋ ํฌ
์ด๋ค ๊ฒ์ด ๊ฐ์ฅ ์ข์๊น์? ํ์ฌ๋ง๋ค ๋ค๋ฅธ ์ต์
์ ์ ํํ๋ ์ด์ ๋ ๋ฌด์์ธ๊ฐ์?
From fb0fc45374b3c159ccd82207ef02ece0dc755f14 Mon Sep 17 00:00:00 2001
From: Deadintegral
Date: Mon, 5 Feb 2024 00:01:28 +0900
Subject: [PATCH 15/16] docs: Proofread spacing, vocabulary, and more
---
translations/README-kr.md | 214 +++++++++++++++++++-------------------
1 file changed, 107 insertions(+), 107 deletions(-)
diff --git a/translations/README-kr.md b/translations/README-kr.md
index a64f6c2..be66c11 100644
--- a/translations/README-kr.md
+++ b/translations/README-kr.md
@@ -137,7 +137,7 @@
Modern, high-performance, Protocol Buffersย
- ๋ง์ดํฌ๋ก ์๋น์ค ์ํคํ
์ฒ์ ์ ํฉ
+ ๋ง์ดํฌ๋ก์๋น์ค ์ํคํ
์ฒ์ ์ ํฉ
- WebSocket:ย
@@ -174,13 +174,13 @@ GraphQL
- ํด๋ผ์ด์ธํธ๊ฐ ํ์ํ ๋ฐ์ดํฐ๋ฅผ ์ ํํ๊ฒ ์ฟผ๋ฆฌํ ์ ์๋ ๋จ์ผ ์๋ํฌ์ธํธ๋ฅผ ์ ๊ณตํฉ๋๋ค.
- ํด๋ผ์ด์ธํธ๊ฐ ์ค์ฒฉ ์ฟผ๋ฆฌ์ ํ์ํ ์ ํํ ํ๋๋ฅผ ์ง์ ํ๋ฉด ์๋ฒ๋ ํด๋น ํ๋๋ง ํฌํจํ ์ต์ ํ๋ ํ์ด๋ก๋๋ฅผ ๋ฐํํฉ๋๋ค.
- ๋ฐ์ดํฐ ์์ ์ ์ํ ๋ฎคํ
์ด์
๊ณผ ์ค์๊ฐ ์๋ฆผ์ ์ํ ๊ตฌ๋
์ ์ง์ํฉ๋๋ค.
-- ์ฌ๋ฌ ์์ค์ ๋ฐ์ดํฐ๋ฅผ ์์งํ๋๋ฐ ์ ํฉํ๋ฉฐ ๋น ๋ฅด๊ฒ ์งํํ๋ ํ๋ฐํธ์๋ ์๊ตฌ์ฌํญ์ ์ ๋ง์ต๋๋ค.
+- ์ฌ๋ฌ ์์ค์ ๋ฐ์ดํฐ๋ฅผ ์์งํ๋๋ฐ ์ ํฉํ๋ฉฐ ๋น ๋ฅด๊ฒ ์งํํ๋ ํ๋ก ํธ์๋ ์๊ตฌ์ฌํญ์ ์ ๋ง์ต๋๋ค.
- ํ์ง๋ง ๋ณต์ก์ฑ์ ํด๋ผ์ด์ธํธ ์ธก์ผ๋ก ์ ๊ฐํ๋ฉฐ, ์ ๋๋ก ๋ณดํธํ์ง ์์ผ๋ฉด ์
์์ ์ธ ์ฟผ๋ฆฌ๋ฅผ ํ์ฉํ ์ ์์ต๋๋ค.
- ์บ์ฑ ์ ๋ต์ REST๋ณด๋ค ๋ ๋ณต์กํ ์ ์์ต๋๋ค.
-์ ํ๋ฆฌ์ผ์ด์
๊ณผ ๊ฐ๋ฐํ์ ๊ตฌ์ฒด์ ์ธ ์๊ตฌ์ฌํญ์ ๋ฐ๋ผ REST์ GraphQL ์ค ์ ํฉํ ๊ฒ์ ์ ํํด์ผ ํฉ๋๋ค. GraphQL์ ๋ณต์กํ๊ฑฐ๋ ์์ฃผ ๋ณ๊ฒฝ๋๋ ํ๋ฐํธ์๋ ์๊ตฌ์ฌํญ์ ์ ํฉํ๋ฉฐ, REST๋ ๋จ์ํ๊ณ ์ผ๊ด๋ ๊ณ์ฝ์ด ์ ํธ๋๋ ์ ํ๋ฆฌ์ผ์ด์
์ ์ ํฉํฉ๋๋ค.
+์ ํ๋ฆฌ์ผ์ด์
๊ณผ ๊ฐ๋ฐํ์ ๊ตฌ์ฒด์ ์ธ ์๊ตฌ์ฌํญ์ ๋ฐ๋ผ REST์ GraphQL ์ค ์ ํฉํ ๊ฒ์ ์ ํํด์ผ ํฉ๋๋ค. GraphQL์ ๋ณต์กํ๊ฑฐ๋ ์์ฃผ ๋ณ๊ฒฝ๋๋ ํ๋ก ํธ์๋ ์๊ตฌ์ฌํญ์ ์ ํฉํ๋ฉฐ, REST๋ ๋จ์ํ๊ณ ์ผ๊ด๋ ๊ณ์ฝ์ด ์ ํธ๋๋ ์ ํ๋ฆฌ์ผ์ด์
์ ์ ํฉํฉ๋๋ค.
-๋ API ๋ฐฉ์ ๋ชจ๋ ์์ด์์ ์๋๋๋ค. ์ฌ๋ฐ๋ฅธ ์คํ์ผ์ ์ ํํ๋ ค๋ฉด ์๊ตฌ ์ฌํญ๊ณผ ์ฅ๋จ์ ์ ์ ์คํ๊ฒ ํ๊ฐํ๋ ๊ฒ์ด ์ค์ํฉ๋๋ค. REST์ GraphQL์ ๋ชจ๋ ๋ฐ์ดํฐ๋ฅผ ๋
ธ์ถํ๊ณ ์ต์ ์ ํ๋ฆฌ์ผ์ด์
์ ๊ตฌ๋ํ๋ ๋ฐ ์ ํจํ ์ต์
์
๋๋ค.
+๋ API ๋ฐฉ์ ๋ชจ๋ ์์ด์์ ์๋๋๋ค. ์ฌ๋ฐ๋ฅธ ์คํ์ผ์ ์ ํํ๋ ค๋ฉด ์๊ตฌ ์ฌํญ๊ณผ ์ฅ๋จ์ ์ ์ ์คํ๊ฒ ๊ฒํ ํ๋ ๊ฒ์ด ์ค์ํฉ๋๋ค. REST์ GraphQL์ ๋ชจ๋ ๋ฐ์ดํฐ๋ฅผ ๋
ธ์ถํ๊ณ ์ต์ ์ ํ๋ฆฌ์ผ์ด์
์ ๊ตฌ๋ํ๋ ๋ฐ ์ ํจํ ์ต์
์
๋๋ค.
### gRPC๋ ์ด๋ป๊ฒ ์๋ํ๋์?
@@ -231,7 +231,7 @@ RPC(Remote Procedure Call)๋ ๋ง์ดํฌ๋ก์๋น์ค ์ํคํ
์ฒ์์ ์๋น์ค
์ด๋ฌํ ๋ฐฉ์์ผ๋ก ํ๋ก๊ทธ๋๋ฐ ํจ๋ฌ๋ค์์ด ๋ฐ๋๊ณ ๊ฒฐ์ ์๋น์ค๋ ๋ ์ด์ ๊ฒฐ์ ์ํ๋ฅผ ํด๋งํ๊ธฐ ์ํด ๋ฆฌ์์ค๋ฅผ ๋ญ๋นํ ํ์๊ฐ ์์ต๋๋ค.
-PSP๊ฐ ๋ค์ ์๋ตํ์ง ์์ผ๋ฉด ์ด๋ป๊ฒ ํ๋์? ๋งค์๊ฐ ๊ฒฐ์ ์ํ๋ฅผ ํ์ธํ๋๋ก ํ์ฐ์คํคํ ์์
์ ์ค์ ํ ์ ์์ต๋๋ค.
+PSP๊ฐ ๋ค์ ์๋ตํ์ง ์์ผ๋ฉด ์ด๋ป๊ฒ ํ๋์? ๋งค ์๊ฐ ๊ฒฐ์ ์ํ๋ฅผ ํ์ธํ๋๋ก ํ์ฐ์คํคํ ์์
์ ์ค์ ํ ์ ์์ต๋๋ค.
์นํ
์ ์๋ฒ๊ฐ ํด๋ผ์ด์ธํธ์ HTTP ์์ฒญ์ ๋ณด๋ด๊ธฐ ๋๋ฌธ์ ๋ฆฌ๋ฒ์ค API ๋๋ ํธ์ API๋ผ๊ณ ๋ ๋ถ๋ฆฝ๋๋ค. ์นํ
์ ์ฌ์ฉํ ๋๋ ๋ค์ ์ธ ๊ฐ์ง ์ฌํญ์ ์ฃผ์ํด์ผ ํฉ๋๋ค.
@@ -366,7 +366,7 @@ Server Error (500-599)
8๋จ๊ณ - API ๊ฒ์ดํธ์จ์ด๊ฐ ์์ฒญ์ ์ ์ ํ ํ๋กํ ์ฝ๋ก ๋ณํํ์ฌ ๋ฐฑ์๋ ๋ง์ดํฌ๋ก์๋น์ค๋ก ์ ์กํฉ๋๋ค.
-9-12๋จ๊ณ: API ๊ฒ์ดํธ์จ์ด๋ ์ค๋ฅ๋ฅผ ์ ์ ํ๊ฒ ์ฒ๋ฆฌํ๊ณ , ๋ณต๊ตฌํ๋ ๋ฐ ์๊ฐ์ด ์ค๋ ๊ฑธ๋ฆฌ๋ ์ค๋ฅ๊ฐ ๋ฐ์ํ๋ ๊ฒฝ์ฐ ์ฅ์ ๋ฅผ ์ฒ๋ฆฌํฉ๋๋ค.(circuit break) ๋ํ ๋ก๊น
๊ณผ ๋ชจ๋ํฐ๋ง์ ์ํด ELK(Elastic-Logstash-Kibana) ์คํ์ ํ์ฉํ ์ ์์ต๋๋ค. ๋๋๋ก API ๊ฒ์ดํธ์จ์ด์ ๋ฐ์ดํฐ๋ฅผ ์บ์ํ๊ธฐ๋ ํฉ๋๋ค.
+9-12๋จ๊ณ: API ๊ฒ์ดํธ์จ์ด๋ ์ค๋ฅ๋ฅผ ์ ์ ํ๊ฒ ์ฒ๋ฆฌํ๊ณ , ๋ณต๊ตฌํ๋๋ฐ ์๊ฐ์ด ์ค๋ ๊ฑธ๋ฆฌ๋ ์ค๋ฅ๊ฐ ๋ฐ์ํ๋ ๊ฒฝ์ฐ ์ฅ์ ๋ฅผ ์ฒ๋ฆฌํฉ๋๋ค.(circuit break) ๋ํ ๋ก๊น
๊ณผ ๋ชจ๋ํฐ๋ง์ ์ํด ELK(Elastic-Logstash-Kibana) ์คํ์ ํ์ฉํ ์ ์์ต๋๋ค. ๋๋๋ก API ๊ฒ์ดํธ์จ์ด์ ๋ฐ์ดํฐ๋ฅผ ์บ์ํ๊ธฐ๋ ํฉ๋๋ค.
### ํจ๊ณผ์ ์ด๊ณ ์์ ํ API๋ฅผ ์ค๊ณํ๋ ค๋ฉด ์ด๋ป๊ฒ ํด์ผ ํ ๊น์?
@@ -377,7 +377,7 @@ Server Error (500-599)
-API ์ค๊ณ๋ ๋จ์ํ URL path ์ค๊ณ๊ฐ ์๋๋ผ๋ ์ ์ ์ ์ํ์ธ์. ๋๋ถ๋ถ์ ๊ฒฝ์ฐ ์ ์ ํ ๋ฆฌ์์ค ์ด๋ฆ, ์๋ณ์, path ํจํด์ ์ ํํด์ผ ํฉ๋๋ค. ์ ์ ํ HTTP ํค๋ ํ๋๋ฅผ ์ค๊ณํ๊ฑฐ๋ API ๊ฒ์ดํธ์จ์ด ๋ด์์ ํจ๊ณผ์ ์ธ rate limit ๊ท์น์ ์ค๊ณํ๋ ๊ฒ๋ ๋ง์ฐฌ๊ฐ์ง๋ก ์ค์ํฉ๋๋ค.
+API ์ค๊ณ๋ ๋จ์ํ URL path ์ค๊ณ๊ฐ ์๋๋ผ๋ ์ ์ ์ ์ํ์ธ์. ๋๋ถ๋ถ์ ๊ฒฝ์ฐ ์ ์ ํ ๋ฆฌ์์ค ์ด๋ฆ, ์๋ณ์, path ํจํด์ ์ ํํด์ผ ํฉ๋๋ค. ์ ์ ํ HTTP ํค๋ ํ๋๋ฅผ ์ค๊ณํ๊ฑฐ๋ API ๊ฒ์ดํธ์จ์ด ๋ด์์ ํจ๊ณผ์ ์ธ ๋ ์ดํธ ๋ฆฌ๋ฏธํธ ๊ท์น์ ์ค๊ณํ๋ ๊ฒ๋ ๋ง์ฐฌ๊ฐ์ง๋ก ์ค์ํฉ๋๋ค.
### TCP/IP encapsulation
@@ -391,11 +391,11 @@ API ์ค๊ณ๋ ๋จ์ํ URL path ์ค๊ณ๊ฐ ์๋๋ผ๋ ์ ์ ์ ์ํ์ธ์.
1๋จ๊ณ: ๋๋ฐ์ด์ค A๊ฐ ๋คํธ์ํฌ์์ HTTP ํ๋กํ ์ฝ์ ํตํด ์ฅ์น B๋ก ๋ฐ์ดํฐ๋ฅผ ์ ์กํ ๋, ๋จผ์ ์์ฉ ๊ณ์ธต์์ HTTP ํค๋๊ฐ ์ถ๊ฐ๋ฉ๋๋ค.
-2๋จ๊ณ: ๊ทธ๋ฐ ๋ค์ TCP ํน์ UDP ํค๋๊ฐ ๋ฐ์ดํฐ์ ์ถ๊ฐ๋ฉ๋๋ค. ์ด ํค๋๋ ์ ์ก ๊ณ์ธต์์ TCP ์ธ๊ทธ๋จผํธ๋ก ์บก์ํ๋ฉ๋๋ค. ํค๋์๋ ์์ค ํฌํธ, ๋ฐ์คํฐ๋ค์ด์
ํฌํธ, ์ํ์ค ๋๋ฒ๊ฐ ํฌํจ๋ฉ๋๋ค.
+2๋จ๊ณ: ๊ทธ๋ฐ ๋ค์ TCP ํน์ UDP ํค๋๊ฐ ๋ฐ์ดํฐ์ ์ถ๊ฐ๋ฉ๋๋ค. ์ด ํค๋๋ ์ ์ก ๊ณ์ธต์์ TCP ์ธ๊ทธ๋จผํธ๋ก ์บก์ํ๋ฉ๋๋ค. ํค๋์๋ ์ถ๋ฐ์ง ํฌํธ, ๋์ฐฉ์ง ํฌํธ, ์ํ์ค ๋๋ฒ๊ฐ ํฌํจ๋ฉ๋๋ค.
-3๋จ๊ณ: ๊ทธ๋ฐ ๋ค์ ์ธ๊ทธ๋จผํธ๋ ๋คํธ์ํฌ ๊ณ์ธต์์ IP ํค๋๋ก ์บก์ํ๋ฉ๋๋ค. IP ํค๋์๋ ์์ค/๋ฐ์คํฐ๋ค์ด์
IP ์ฃผ์๊ฐ ํฌํจ๋ฉ๋๋ค.
+3๋จ๊ณ: ๊ทธ๋ฐ ๋ค์ ์ธ๊ทธ๋จผํธ๋ ๋คํธ์ํฌ ๊ณ์ธต์์ IP ํค๋๋ก ์บก์ํ๋ฉ๋๋ค. IP ํค๋์๋ ์ถ๋ฐ์ง/๋์ฐฉ์ง IP ์ฃผ์๊ฐ ํฌํจ๋ฉ๋๋ค.
-4๋จ๊ณ: ๋ฐ์ดํฐ ๋งํฌ ๊ณ์ธต์์ IP ๋ฐ์ดํฐ๊ทธ๋จ์ ์์ค/๋ฐ์คํฐ๋ค์ด์
MAC ์ฃผ์์ ํจ๊ป MAC ํค๋๊ฐ ์ถ๊ฐ๋ฉ๋๋ค.
+4๋จ๊ณ: ๋ฐ์ดํฐ ๋งํฌ ๊ณ์ธต์์ IP ๋ฐ์ดํฐ๊ทธ๋จ์ ์ถ๋ฐ์ง/๋์ฐฉ์ง MAC ์ฃผ์์ ํจ๊ป MAC ํค๋๊ฐ ์ถ๊ฐ๋ฉ๋๋ค.
5๋จ๊ณ: ์บก์ํ๋ ํ๋ ์์ด ๋ฌผ๋ฆฌ ๊ณ์ธต์ผ๋ก ์ ์ก๋๊ณ ๋คํธ์ํฌ๋ฅผ ํตํด 2์ง์ ๋นํธ๋ก ์ ์ก๋ฉ๋๋ค.
@@ -487,7 +487,7 @@ URL์ Uniform Resource Locator์ ์ฝ์๋ก, HTTP์ ํต์ฌ ๊ฐ๋
์
๋๋ค.
URN์ Uniform Resource Name์ ์ฝ์๋ก, urn ์คํค๋ง๋ฅผ ์ฌ์ฉํฉ๋๋ค. URN์ ๋ฆฌ์์ค๋ฅผ ์ฐพ๋ ๋ฐ ์ฌ์ฉํ ์ ์์ต๋๋ค. ๋ค์ด์ด๊ทธ๋จ์ ์ ์๋ ๊ฐ๋จํ ์๋ ๋ค์์คํ์ด์ค์ ๋ค์์คํ์ด์ค ํน์ ๋ฌธ์์ด๋ก ๊ตฌ์ฑ๋์ด ์์ต๋๋ค.
-์ด ์ฃผ์ ์ ๋ํด ๋ ์์ธํ ์์๋ณด๋ ค๋ฉด ๋ค์์ ์ถ์ฒํฉ๋๋ค. [W3Cโs clarification](https://www.w3.org/TR/uri-clarification/).
+์ด ์ฃผ์ ์ ๋ํด ๋ ์์ธํ ์์๋ณด๋ ค๋ฉด [W3Cโs clarification](https://www.w3.org/TR/uri-clarification/)์ ์ถ์ฒํฉ๋๋ค.
## CI/CD
@@ -499,9 +499,9 @@ URN์ Uniform Resource Name์ ์ฝ์๋ก, urn ์คํค๋ง๋ฅผ ์ฌ์ฉํฉ๋๋ค. URN
์น์
1 - CI/CD๊ฐ ํฌํจ๋ ์ํํธ์จ์ด ๊ฐ๋ฐ ์๋ช
์ฃผ๊ธฐ
-์ํํธ์จ์ด ๊ฐ๋ฐ ์๋ช
์ฃผ๊ธฐ(SDLC)๋ ๊ฐ๋ฐ, ํ
์คํธ, ๋ฐฐํฌ, ์ ์ง ๊ด๋ฆฌ ๋ฑ ๋ช ๊ฐ์ง ์ฃผ์ ๋จ๊ณ๋ก ๊ตฌ์ฑ๋ฉ๋๋ค. CI/CD๋ ์ด๋ฌํ ๋จ๊ณ๋ฅผ ์๋ํํ๊ณ ํตํฉํ์ฌ ๋ ๋น ๋ฅด๊ณ ์์ ์ ์ธ ๋ฆด๋ฆฌ์ค๋ฅผ ๊ฐ๋ฅํ๊ฒ ํฉ๋๋ค.
+์ํํธ์จ์ด ๊ฐ๋ฐ ์๋ช
์ฃผ๊ธฐ(SDLC)๋ ๊ฐ๋ฐ, ํ
์คํธ, ๋ฐฐํฌ, ์ ์ง๋ณด์ ๋ฑ ๋ช ๊ฐ์ง ์ฃผ์ ๋จ๊ณ๋ก ๊ตฌ์ฑ๋ฉ๋๋ค. CI/CD๋ ์ด๋ฌํ ๋จ๊ณ๋ฅผ ์๋ํํ๊ณ ํตํฉํ์ฌ ๋ ๋น ๋ฅด๊ณ ์์ ์ ์ธ ๋ฆด๋ฆฌ์ค๋ฅผ ๊ฐ๋ฅํ๊ฒ ํฉ๋๋ค.
-์ฝ๋๊ฐ git ๋ฆฌํฌ์งํ ๋ฆฌ์ ํธ์๋๋ฉด ์๋ํ๋ ๋น๋ ๋ฐ ํ
์คํธ ํ๋ก์ธ์ค๊ฐ ์์๋ฉ๋๋ค. ์ฝ๋์ ์ ํจ์ฑ์ ๊ฒ์ฌํ๊ธฐ ์ํด ์๋ํฌ์๋(e2e) ํ
์คํธ ์ผ์ด์ค๊ฐ ์คํ๋ฉ๋๋ค. ํ
์คํธ๋ฅผ ํต๊ณผํ๋ฉด ์ฝ๋๋ฅผ ์คํ
์ด์ง/ํ๋ก๋์
ํ๊ฒฝ์ ์๋์ผ๋ก ๋ฐฐํฌํ ์ ์์ต๋๋ค. ์ด์๊ฐ ๋ฐ๊ฒฌ๋๋ฉด ์ฝ๋๋ ๋ฒ๊ทธ ์์ ์ ์ํด ๊ฐ๋ฐ ๋จ๊ณ๋ก ๋ค์ ๋ณด๋ด์ง๋๋ค. ์ด๋ฌํ ์๋ํ๋ ๊ฐ๋ฐ์์๊ฒ ์ ์ํ ํผ๋๋ฐฑ์ ์ ๊ณตํ๊ณ ํ๋ก๋์
ํ๊ฒฝ์์ ๋ฐ์ํ๋ ๋ฒ๊ทธ ์ํ์ ์ค์ฌ์ค๋๋ค.
+์ฝ๋๊ฐ git ๋ฆฌํฌ์งํ ๋ฆฌ์ ํธ์๋๋ฉด ์๋ํ๋ ๋น๋, ํ
์คํธ ํ๋ก์ธ์ค๊ฐ ์์๋ฉ๋๋ค. ์ฝ๋์ ์ ํจ์ฑ์ ๊ฒ์ฌํ๊ธฐ ์ํด ์๋ํฌ์๋(e2e) ํ
์คํธ ์ผ์ด์ค๊ฐ ์คํ๋ฉ๋๋ค. ํ
์คํธ๋ฅผ ํต๊ณผํ๋ฉด ์ฝ๋๋ฅผ ์คํ
์ด์ง/ํ๋ก๋์
ํ๊ฒฝ์ ์๋์ผ๋ก ๋ฐฐํฌํ ์ ์์ต๋๋ค. ์ด์๊ฐ ๋ฐ๊ฒฌ๋๋ฉด ์ฝ๋๋ ๋ฒ๊ทธ ์์ ์ ์ํด ๊ฐ๋ฐ ๋จ๊ณ๋ก ๋ค์ ๋ณด๋ด์ง๋๋ค. ์ด๋ฌํ ์๋ํ๋ ๊ฐ๋ฐ์์๊ฒ ์ ์ํ ํผ๋๋ฐฑ์ ์ ๊ณตํ๊ณ ํ๋ก๋์
ํ๊ฒฝ์์ ๋ฐ์ํ๋ ๋ฒ๊ทธ ์ํ์ ์ค์ฌ์ค๋๋ค.
์น์
2 - CI์ CD์ ์ฐจ์ด์
@@ -515,10 +515,10 @@ Continuous Delivery(CD)๋ ์ธํ๋ผ ๋ณ๊ฒฝ, ๋ฐฐํฌ์ ๊ฐ์ ๋ฆด๋ฆฌ์ค ํ๋ก
- ๊ฐ๋ฐ์๊ฐ ์ฝ๋ ๋ณ๊ฒฝ ์ฌํญ์ ์์ค ์ปจํธ๋กค์ ์ปค๋ฐํฉ๋๋ค.
- CI ์๋ฒ๊ฐ ๋ณ๊ฒฝ ์ฌํญ์ ๊ฐ์งํ๊ณ ๋น๋๋ฅผ ํธ๋ฆฌ๊ฑฐํฉ๋๋ค.
- ์ฝ๋๊ฐ ์ปดํ์ผ๋๊ณ ํ
์คํธ๋ฉ๋๋ค(๋จ์ ํ
์คํธ, ํตํฉ ํ
์คํธ).
-- ํ
์คํธ ๊ฒฐ๊ณผ๋ฅผ ๊ฐ๋ฐ์์๊ฒ ๋ณด๊ณ ๋ฉ๋๋ค.
+- ํ
์คํธ ๊ฒฐ๊ณผ๋ฅผ ๊ฐ๋ฐ์์๊ฒ ๋ณด๊ณ ํฉ๋๋ค.
- ์ฑ๊ณตํ๋ฉด ์ํฐํฉํธ๊ฐ ์คํ
์ด์ง ํ๊ฒฝ์ ๋ฐฐํฌ๋ฉ๋๋ค.
- ๋ฆด๋ฆฌ์ค ์ ์ ์คํ
์ด์ง ํ๊ฒฝ์์ ์ถ๊ฐ ํ
์คํธ๋ฅผ ์ํํ ์ ์์ต๋๋ค.
-- CD ์์คํ
์ด ์น์ธํ ๋ณ๊ฒฝ ์ฌํญ์ ํ๋ก๋์
์ ๋ฐฐํฌํฉ๋๋ค.
+- CD ์์คํ
์ด ์น์ธ๋ ๋ณ๊ฒฝ ์ฌํญ์ ํ๋ก๋์
์ ๋ฐฐํฌํฉ๋๋ค.
### ๋ทํ๋ฆญ์ค ๊ธฐ์ ์คํ (CI/CD Pipeline)
@@ -534,7 +534,7 @@ Continuous Delivery(CD)๋ ์ธํ๋ผ ๋ณ๊ฒฝ, ๋ฐฐํฌ์ ๊ฐ์ ๋ฆด๋ฆฌ์ค ํ๋ก
ํจํค์ง: ํจํค์ง ๋ฐ ์์กด์ฑ์ ๋ฆด๋ฆฌ์ค๋ฅผ ์ํด ์๋ง์กด ๋จธ์ ์ด๋ฏธ์ง(AMI)์ ํจํค์ง๋ฉ๋๋ค.
-ํ
์คํ
: Testing emphasizes the production culture's focus on building chaos tools.
+ํ
์คํ
: ํ
์คํธ๋ ์นด์ค์ค ํด(์์คํ
์ ์์์น ๋ชปํ ์ฅ์ ๋ ํธ๋ํฝ์ ๋ฐ์์์ผ ์์คํ
์ ์์ ์ฑ์ ํ
์คํธํ๋ ๋๊ตฌ)์ ๊ตฌ์ถํ๋ ๋ฐ ์ค์ ์ ๋๋ ํ๋ก๋์
๋ฌธํ๋ฅผ ๊ฐ์กฐํฉ๋๋ค.
๋ฐฐํฌ: ๋ทํ๋ฆญ์ค๋ ์นด๋๋ฆฌ ๋กค์์ ๋ฐฐํฌ์ ์์ฒด ๊ตฌ์ถํ Spinnaker๋ฅผ ์ฌ์ฉํฉ๋๋ค.
@@ -552,13 +552,13 @@ Continuous Delivery(CD)๋ ์ธํ๋ผ ๋ณ๊ฒฝ, ๋ฐฐํฌ์ ๊ฐ์ ๋ฆด๋ฆฌ์ค ํ๋ก
- ๊ฐ์ฅ ์ค๋๋ ํจํด์ธ MVC๋ ๊ฑฐ์ 50๋
์ ์ผ๋ก ๊ฑฐ์ฌ๋ฌ ์ฌ๋ผ๊ฐ๋๋ค.
-- ๋ชจ๋ ํจํด์๋ ์ฝํ
์ธ ๋ฅผ ํ์ํ๊ณ ์ฌ์ฉ์ ์
๋ ฅ์ ์์ ํ๋ 'view'(V)๊ฐ ์์ต๋๋ค.
-- ๋๋ถ๋ถ์ ํจํด์๋ ๋น์ฆ๋์ค ๋ฐ์ดํฐ๋ฅผ ๊ด๋ฆฌํ๊ธฐ ์ํ 'model'(M)์ด ํฌํจ๋ฉ๋๋ค.
-- "Controller", " presenter", "view-model"์ ๋ทฐ์ ๋ชจ๋ธ(VIPER ํจํด์ "entity") ์ฌ์ด๋ฅผ ๋งค๊ฐํ๋ ๋ณํ๊ธฐ์
๋๋ค.
+- ๋ชจ๋ ํจํด์๋ ์ฝํ
์ธ ๋ฅผ ํ์ํ๊ณ ์ฌ์ฉ์ ์
๋ ฅ์ ์์ ํ๋ view(V)๊ฐ ์์ต๋๋ค.
+- ๋๋ถ๋ถ์ ํจํด์๋ ๋น์ฆ๋์ค ๋ฐ์ดํฐ๋ฅผ ๊ด๋ฆฌํ๊ธฐ ์ํ model(M)์ด ํฌํจ๋ฉ๋๋ค.
+- Controller, presenter, view-model์ ๋ทฐ์ ๋ชจ๋ธ(VIPER ํจํด์ entity) ์ฌ์ด๋ฅผ ๋งค๊ฐํ๋ ๋ณํ๊ธฐ์
๋๋ค.
### ๋ชจ๋ ๊ฐ๋ฐ์๊ฐ ์์์ผ ํ 18๊ฐ์ง ํต์ฌ ๋์์ธ ํจํด
-ํจํด์ ์ผ๋ฐ์ ์ธ ์ค๊ณ ๋ฌธ์ ์ ๋ํ ์ฌ์ฌ์ฉ ๊ฐ๋ฅํ ์๋ฃจ์
์ผ๋ก, ๋ณด๋ค ์ํํ๊ณ ํจ์จ์ ์ธ ๊ฐ๋ฐ ํ๋ก์ธ์ค๋ฅผ ๊ฐ๋ฅํ๊ฒ ํฉ๋๋ค. ํจํด์ ๋ ๋์ ์ํํธ์จ์ด ๊ตฌ์กฐ๋ฅผ ๊ตฌ์ถํ๊ธฐ ์ํ ์ฒญ์ฌ์ง ์ญํ ์ ํฉ๋๋ค. ๋ค์์ ๊ฐ์ฅ ๋ง์ด ์ฌ์ฉ๋๋ ํจํด ์ค ์ผ๋ถ์
๋๋ค.
+ํจํด์ ์ผ๋ฐ์ ์ธ ์ค๊ณ ๋ฌธ์ ์ ๋ํ ์ฌ์ฌ์ฉ ๊ฐ๋ฅํ ์๋ฃจ์
์ผ๋ก, ๋ณด๋ค ์ํํ๊ณ ํจ์จ์ ์ธ ๊ฐ๋ฐ ํ๋ก์ธ์ค๋ฅผ ๊ฐ๋ฅํ๊ฒ ํฉ๋๋ค. ํจํด์ ๋ ๋์ ์ํํธ์จ์ด ๊ตฌ์กฐ๋ฅผ ๊ตฌ์ถํ๊ธฐ ์ํ ์ค๊ณ๋(blueprint) ์ญํ ์ ํฉ๋๋ค. ๋ค์์ ๊ฐ์ฅ ๋ง์ด ์ฌ์ฉ๋๋ ํจํด ์ค ์ผ๋ถ์
๋๋ค.
@@ -577,7 +577,7 @@ Continuous Delivery(CD)๋ ์ธํ๋ผ ๋ณ๊ฒฝ, ๋ฐฐํฌ์ ๊ฐ์ ๋ฆด๋ฆฌ์ค ํ๋ก
- Proxy: Stand-In Actor - ๋ค๋ฅธ ๊ฐ์ฒด๋ฅผ ๋ํํ์ฌ ์ก์ธ์ค ๋๋ ์์
์ ์ ์ดํฉ๋๋ค.
- Chain of Responsibility: Request Relay - ์์ฒญ์ ์ฒ๋ฆฌํ ๋๊น์ง ๊ฐ์ฒด ์ฒด์ธ์ ํตํด ์ ๋ฌํฉ๋๋ค.
- Command: Task Wrapper - ์์ฒญ์ ๊ฐ์ฒด๋ก ๋ณํํ์ฌ ์์
์ค๋น๋ฅผ ๊ฐ์ถ๊ฒ ํฉ๋๋ค.
-- Iterator: Collection Explorer - ์ปฌ๋ ์
์ ์์์ ํ๋์ฉ ์ก์ธ์คํฉ๋๋ค.
+- Iterator: Collection Explorer - ์ปฌ๋ ์
์์์ ํ๋์ฉ ์ก์ธ์คํฉ๋๋ค.
- Mediator: Communication Hub - ์๋ก ๋ค๋ฅธ ํด๋์ค ๊ฐ์ ์ธํฐ๋์
์ ๊ฐ์ํํฉ๋๋ค.
- Memento: Time Capsule - ๊ฐ์ฒด์ ์ํ๋ฅผ ์บก์ฒํ๊ณ ๋ณต์ํฉ๋๋ค.
- Observer: News Broadcaster - ๋ค๋ฅธ ๊ฐ์ฒด์ ๋ณ๊ฒฝ์ ๋ํด ํด๋์ค์๊ฒ ์๋ฆฝ๋๋ค.
@@ -595,11 +595,11 @@ Continuous Delivery(CD)๋ ์ธํ๋ผ ๋ณ๊ฒฝ, ๋ฐฐํฌ์ ๊ฐ์ ๋ฆด๋ฆฌ์ค ํ๋ก
์ด ์นํธ์ํธ๊ฐ ํ๋ก์ ํธ์ ์๊ตฌ์ฌํญ์ ๋ง๋ ์ฌ๋ฐ๋ฅธ ์๋น์ค๋ฅผ ์ฐพ์๋ด๊ณ ์ ์ฌ์ ์ธ ํจ์ ์ ํผํ๋ ๋ฐ ๋์์ด ๋๊ธฐ๋ฅผ ๋ฐ๋๋๋ค.
-์ฐธ๊ณ : Google์ ๋ฐ์ดํฐ๋ฒ ์ด์ค ์ ์ฆ์ผ์ด์ค์ ๋ํ ๋ฌธ์๊ฐ ์ ํ๋์ด ์์ต๋๋ค. ์ฌ์ฉ ๊ฐ๋ฅํ ์๋ฃ๋ฅผ ์ต๋ํ ๊ฒํ ํ๊ณ ์ต์ ์ ์ต์
์ ์ ์ํ์ง๋ง, ์ผ๋ถ ํญ๋ชฉ์ ๋ ์ ํํ ์ ๋ณด๊ฐ ํ์ํ ์ ์์ต๋๋ค.
+์ฐธ๊ณ : ๊ตฌ๊ธ์ ๋ฐ์ดํฐ๋ฒ ์ด์ค ์ ์ฆ์ผ์ด์ค์ ๋ํ ๋ฌธ์๊ฐ ์ ํ๋์ด ์์ต๋๋ค. ์ฌ์ฉ ๊ฐ๋ฅํ ์๋ฃ๋ฅผ ์ต๋ํ ๊ฒํ ํ๊ณ ์ต์ ์ ์ต์
์ ์ ์ํ์ง๋ง, ์ผ๋ถ ํญ๋ชฉ์ ๋ ์ ํํ ์ ๋ณด๊ฐ ํ์ํ ์ ์์ต๋๋ค.
### ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ฅผ ๊ฐํํ๋ 8๊ฐ์ง ๋ฐ์ดํฐ ๊ตฌ์กฐ
-์ ๋ต์ ์ ์ฆ์ผ์ด์ค์ ๋ฐ๋ผ ๋ฌ๋ผ์ง๋๋ค. ๋ฐ์ดํฐ๋ ๋ฉ๋ชจ๋ฆฌ๋ ๋์คํฌ์ ์ธ๋ฑ์ค๋ ์ ์์ต๋๋ค. ๋ง์ฐฌ๊ฐ์ง๋ก ๋ฐ์ดํฐ ํฌ๋งท๋ ๋๋ฒ, ์คํธ๋ง, ์ง๋ฆฌ์ ์ขํ ๋ฑ ๋ค์ํฉ๋๋ค. ์์คํ
์ด ์ฐ๊ธฐ ์ค์ฌ์ผ ์๋ ์๊ณ ์ฝ๊ธฐ ์ค์ฌ์ผ ์๋ ์์ต๋๋ค. ์ด๋ฌํ ๋ชจ๋ ์์๋ ๋ฐ์ดํฐ๋ฒ ์ด์ค ์ธ๋ฑ์ค ํฌ๋งท ์ ํ์ ์ํฅ์ ๋ฏธ์นฉ๋๋ค.
+์ ๋ต์ ์ ์ฆ์ผ์ด์ค์ ๋ฐ๋ผ ๋ฌ๋ผ์ง๋๋ค. ๋ฐ์ดํฐ๋ ๋ฉ๋ชจ๋ฆฌ๋ ๋์คํฌ์ ์ธ๋ฑ์ค ๋ ์ ์์ต๋๋ค. ๋ง์ฐฌ๊ฐ์ง๋ก ๋ฐ์ดํฐ ํฌ๋งท๋ ๋๋ฒ, ์คํธ๋ง, ์ง๋ฆฌ์ ์ขํ ๋ฑ ๋ค์ํฉ๋๋ค. ์์คํ
์ด ์ฐ๊ธฐ ์ค์ฌ์ผ ์๋, ์ฝ๊ธฐ ์ค์ฌ์ผ ์๋ ์์ต๋๋ค. ์ด๋ฌํ ๋ชจ๋ ์์๋ ๋ฐ์ดํฐ๋ฒ ์ด์ค ์ธ๋ฑ์ค ํฌ๋งท ์ ํ์ ์ํฅ์ ๋ฏธ์นฉ๋๋ค.
@@ -608,8 +608,8 @@ Continuous Delivery(CD)๋ ์ธํ๋ผ ๋ณ๊ฒฝ, ๋ฐฐํฌ์ ๊ฐ์ ๋ฆด๋ฆฌ์ค ํ๋ก
๋ค์์ ๋ฐ์ดํฐ ์ธ๋ฑ์ฑ์ ๊ฐ์ฅ ๋ง์ด ์ฌ์ฉ๋๋ ๋ช ๊ฐ์ง ๋ฐ์ดํฐ ๊ตฌ์กฐ์
๋๋ค.
- Skiplist: ์ผ๋ฐ์ ์ธ ์ธ๋ฉ๋ชจ๋ฆฌ ์ธ๋ฑ์ค ํ์
์ผ๋ก, Redis์์ ์ฌ์ฉ.
-- Hash index: "Map" ๋ฐ์ดํฐ ๊ตฌ์กฐ(๋๋ "Collection")์ ๋งค์ฐ ์ผ๋ฐ์ ์ธ ๊ตฌํ.
-- SSTable: ๋์คํฌ์ ์ด๋ฎคํฐ๋ธ 'Map' ๊ตฌํ
+- Hash index: Map ๋ฐ์ดํฐ ๊ตฌ์กฐ(๋๋ Collection)์ ๋งค์ฐ ์ผ๋ฐ์ ์ธ ๊ตฌํ.
+- SSTable: ๋์คํฌ์ ์ด๋ฎคํฐ๋ธ Map ๊ตฌํ
- LSM tree: Skiplist + SSTable. ๋์ ์ฐ๊ธฐ ์ฒ๋ฆฌ๋.
- B-tree: ๋์คํฌ ๊ธฐ๋ฐ ์๋ฃจ์
. ์ผ๊ด๋ ์ฝ๊ธฐ/์ฐ๊ธฐ ์ฑ๋ฅ.
- Inverted index: ๋ํ๋จผํธ ์ธ๋ฑ์ฑ์ ์ฌ์ฉ. ๋ฃจ์ฌ์์ ์ฌ์ฉ.
@@ -665,7 +665,7 @@ CAP ์ ๋ฆฌ์ ๋ฐ๋ฅด๋ฉด ๋ถ์ฐ ์์คํ
์ ์ด ์ธ ๊ฐ์ง ๋ณด์ฅ ์ค ๋ ๊ฐ์ง
3. ์ด ์ ๋ฆฌ๋ ์ฝ 100%์ ๊ฐ์ฉ์ฑ๊ณผ ์ผ๊ด์ฑ์ ์๋ฏธํฉ๋๋ค. ๋ณด๋ค ํ์ค์ ์ธ ๋
ผ์๋ ๋คํธ์ํฌ ํํฐ์
์ด ์์ ๋ ์ง์ฐ ์๊ฐ๊ณผ ์ผ๊ด์ฑ ๊ฐ์ ์ ์ถฉ์์
๋๋ค. ์์ธํ ๋ด์ฉ์ PACELC ์ ๋ฆฌ๋ฅผ ์ฐธ์กฐํ์ธ์.
-**Is the CAP theorem actually useful?**
+**CAP์ ๋ฆฌ๊ฐ ์ค์ ๋ก ์ ์ฉํ๊ฐ์?**
์ ์ถฉ์์ ๋
ผ์ํ ์ ์๋ค๋ ์ ์์ ์ฌ์ ํ ์ ์ฉํ๋ค๊ณ ์๊ฐํ์ง๋ง, ์ด๋ ์ผ๋ถ๋ถ์ผ ๋ฟ์
๋๋ค. ์ฌ๋ฐ๋ฅธ ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ฅผ ์ ํํ๋ ค๋ฉด ๋ ๊น์ด ํ๊ณ ๋ค์ด์ผ ํฉ๋๋ค.
@@ -706,11 +706,11 @@ SQL ์คํ์ ๋งค์ฐ ๋ณต์กํ๋ฉฐ ๋ค์๊ณผ ๊ฐ์ ๋ง์ ๊ณ ๋ ค ์ฌํญ์ ํฌ
SQL ์ธ์ด์๋ 5๊ฐ์ง ๊ตฌ์ฑ ์์๊ฐ ์์ต๋๋ค.
-- DDL: data definition language. ์: CREATE, ALTER, DROP
-- DQL: data query language. ์: SELECT
-- DML: data manipulation language. ์: INSERT, UPDATE, DELETE
-- DCL: data control language. ์: GRANT, REVOKE
-- TCL: transaction control language. ์: COMMIT, ROLLBACK
+- DDL: ๋ฐ์ดํฐ ์ ์ ์ธ์ด. ์: CREATE, ALTER, DROP
+- DQL: ๋ฐ์ดํฐ ์ฟผ๋ฆฌ ์ธ์ด. ์: SELECT
+- DML: ๋ฐ์ดํฐ ์กฐ์ ์ธ์ด. ์: INSERT, UPDATE, DELETE
+- DCL: ๋ฐ์ดํฐ ์ ์ด ์ธ์ด. ์: GRANT, REVOKE
+- TCL: ํธ๋์ญ์
์ ์ด ์ธ์ด. ์: COMMIT, ROLLBACK
๋ฐฑ์๋ ์์ง๋์ด์ ๊ฒฝ์ฐ ๋๋ถ๋ถ์ ์์์ผ ํ ์๋ ์์ต๋๋ค. ๋ฐ์ดํฐ ๋ถ์๊ฐ๋ผ๋ฉด DQL์ ์ ์ดํดํด์ผ ํ ์๋ ์์ต๋๋ค. ์์ ์๊ฒ ๊ฐ์ฅ ๊ด๋ จ์ฑ์ด ๋์ ์ฃผ์ ๋ฅผ ์ ํํ์ธ์.
@@ -725,21 +725,21 @@ SQL ์ธ์ด์๋ 5๊ฐ์ง ๊ตฌ์ฑ ์์๊ฐ ์์ต๋๋ค.
-ํ๋ก์ฐ๋ฅผ ๋ฐ๋ผ **multiple layers** ๊ฐ ์์ต๋๋ค.
+ํ๋ก์ฐ๋ฅผ ๋ฐ๋ผ **์ฌ๋ฌ ๋ ์ด์ด** ๊ฐ ์์ต๋๋ค.
1. Client apps: HTTP ์๋ต์ ๋ธ๋ผ์ฐ์ ์ ์ํด ์บ์๋ ์ ์์ต๋๋ค. HTTP๋ฅผ ํตํด ์ฒ์์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ์์ฒญํ๋ฉด HTTP ํค๋์ ๋ง๋ฃ ์ ์ฑ
๊ณผ ํจ๊ป ๋ฐํ๋๋ฉฐ, ๋ฐ์ดํฐ๋ฅผ ๋ค์ ์์ฒญํ๋ฉด ํด๋ผ์ด์ธํธ ์ฑ์ด ๋จผ์ ๋ธ๋ผ์ฐ์ ์บ์์์ ๋ฐ์ดํฐ๋ฅผ ๊ฒ์ํ๋ ค๊ณ ์๋ํฉ๋๋ค.
2. CDN: CDN์ ์ ์ ์น ๋ฆฌ์์ค๋ฅผ ์บ์ํฉ๋๋ค. ํด๋ผ์ด์ธํธ๋ ๊ทผ์ฒ์ CDN ๋
ธ๋์์ ๋ฐ์ดํฐ๋ฅผ ๊ฒ์ํ ์ ์์ต๋๋ค.
3. Load Balancer: ๋ก๋ ๋ฐธ๋ฐ์๋ ๋ฆฌ์์ค๋ ์บ์ํ ์ ์์ต๋๋ค.
-4. Messaging infra: Message brokers๊ฐ ๋จผ์ ๋์คํฌ์ ๋ฉ์์ง๋ฅผ ์ ์ฅํ ๋ค์, consumers๋ ์์ ์ ์๋์ ๋ง์ถฐ ๋ฉ์์ง๋ฅผ ๊ฒ์ํฉ๋๋ค. ๋ฆฌํ
์
ํด๋ฆฌ์์ ๋ฐ๋ผ ๋ฐ์ดํฐ๋ ์ผ์ ๊ธฐ๊ฐ ๋์ ์นดํ์นด ํด๋ฌ์คํฐ์ ์บ์๋ฉ๋๋ค.
-5. Services: ์๋น์ค์๋ ์ฌ๋ฌ๊ฐ์ ์บ์ ๊ณ์ธต์ด ์์ต๋๋ค. CPU ์บ์์ ๋ฐ์ดํฐ๊ฐ ์์ผ๋ฉด ๋ฉ๋ชจ๋ฆฌ ์บ์์์ ๊ฒ์์ ์๋ํฉ๋๋ค. ๋๋ก๋ ์๋น์ค๊ฐ ๋์คํฌ์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ ์ธ์ปจ๋ ๋ ๋ฒจ ์บ์๊ฐ ์๋ ๊ฒฝ์ฐ๋ ์์ต๋๋ค.
-6. Distributed Cache: Redis์ ๊ฐ์ ๋ถ์ฐ ์บ์๋ ์ฌ๋ฌ ์๋น์ค์ ๋ํ ํค-๊ฐ ์์ ๋ฉ๋ชจ๋ฆฌ์ ๋ณด๊ดํฉ๋๋ค. ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ณด๋ค ํจ์ฌ ๋ฐ์ด๋ ์ฝ๊ธฐ/์ฐ๊ธฐ ์ฑ๋ฅ์ ์ ๊ณตํฉ๋๋ค.
-7. Full-text Search: ๋ํ๋จผํธ ๊ฒ์์ด๋ ๋ก๊ทธ ๊ฒ์์ ์ํด Elastic Search์ ๊ฐ์ ํ ํ
์คํธ ๊ฒ์์ ์ฌ์ฉํด์ผ ํ ๋๊ฐ ์์ต๋๋ค. ๋ฐ์ดํฐ ์ฌ๋ณธ๋ ๊ฒ์ ์์ง์์ ์ธ๋ฑ์ค๋ฉ๋๋ค.
+4. Messaging infra: ๋ฉ์์ง ๋ธ๋ก์ปค๊ฐ ๋จผ์ ๋์คํฌ์ ๋ฉ์์ง๋ฅผ ์ ์ฅํ ๋ค์, ์ปจ์๋จธ๋ ์์ ์ ์๋์ ๋ง์ถฐ ๋ฉ์์ง๋ฅผ ๊ฒ์ํฉ๋๋ค. ๋ฆฌํ
์
์ ์ฑ
์ ๋ฐ๋ผ ๋ฐ์ดํฐ๋ ์ผ์ ๊ธฐ๊ฐ ๋์ ์นดํ์นด ํด๋ฌ์คํฐ์ ์บ์๋ฉ๋๋ค.
+5. Services: ์๋น์ค์๋ ์ฌ๋ฌ๊ฐ์ ์บ์ ๊ณ์ธต์ด ์์ต๋๋ค. CPU ์บ์์ ๋ฐ์ดํฐ๊ฐ ์์ผ๋ฉด ๋ฉ๋ชจ๋ฆฌ ์บ์์์ ๊ฒ์์ ์๋ํฉ๋๋ค. ๋๋ก๋ ์๋น์ค๊ฐ ๋์คํฌ์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ ์ธ์ปจ๋ ๋ ๋ฒจ ์บ์๊ฐ ์์ ์ ์์ต๋๋ค.
+6. Distributed Cache: Redis์ ๊ฐ์ ๋ถ์ฐ ์บ์๋ ์ฌ๋ฌ ์๋น์ค์ ๋ํ key-value ์์ ๋ฉ๋ชจ๋ฆฌ์ ๋ณด๊ดํฉ๋๋ค. ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ณด๋ค ํจ์ฌ ๋ฐ์ด๋ ์ฝ๊ธฐ/์ฐ๊ธฐ ์ฑ๋ฅ์ ์ ๊ณตํฉ๋๋ค.
+7. Full-text Search: ๋ํ๋จผํธ ๊ฒ์์ด๋ ๋ก๊ทธ ๊ฒ์์ ์ํด Elastic Search์ ๊ฐ์ ํํ
์คํธ ๊ฒ์์ ์ฌ์ฉํด์ผ ํ ๋๊ฐ ์์ต๋๋ค. ๋ฐ์ดํฐ ์ฌ๋ณธ๋ ๊ฒ์ ์์ง์์ ์ธ๋ฑ์ค๋ฉ๋๋ค.
8. Database: ๋ฐ์ดํฐ๋ฒ ์ด์ค ๋ด์์๋ ๋ค์ํ ๋ ๋ฒจ์ ์บ์๊ฐ ์์ต๋๋ค.
- WAL(Write-ahead Log): ๋ฐ์ดํฐ๋ B ํธ๋ฆฌ ์ธ๋ฑ์ค๋ฅผ ๊ตฌ์ถํ๊ธฐ ์ ์ ๋จผ์ WAL์ ๊ธฐ๋ก๋ฉ๋๋ค.
- Bufferpool: ์ฟผ๋ฆฌ ๊ฒฐ๊ณผ๋ฅผ ์บ์ํ๊ธฐ ์ํด ํ ๋น๋ ๋ฉ๋ชจ๋ฆฌ ์์ญ์
๋๋ค.
- Materialized View: ์ฟผ๋ฆฌ ๊ฒฐ๊ณผ๋ฅผ ๋ฏธ๋ฆฌ ๊ณ์ฐํ๊ณ ๋ฐ์ดํฐ๋ฒ ์ด์ค ํ
์ด๋ธ์ ์ ์ฅํ์ฌ ์ฟผ๋ฆฌ ์ฑ๋ฅ์ ํฅ์์ํต๋๋ค.
-- Transaction log: ๋ชจ๋ ํธ๋์ญ์
๊ณผ ๋ฐ์ดํฐ๋ฒ ์ด์ค ์
๋ฐ์ดํธ ๊ธฐ๋กํฉ๋๋ค.
-- Replication Log: ๋ฐ์ดํฐ๋ฒ ์ด์ค ํด๋ฌ์คํฐ์ ๋ณต์ ์ํ๋ฅผ ๊ธฐ๋กํ๋ ๋ฐ ์ฌ์ฉ๋ฉ๋๋ค.
+- Transaction log: ๋ชจ๋ ํธ๋์ญ์
๊ณผ ๋ฐ์ดํฐ๋ฒ ์ด์ค ์
๋ฐ์ดํธ๋ฅผ ๊ธฐ๋กํฉ๋๋ค.
+- Replication Log: ๋ฐ์ดํฐ๋ฒ ์ด์ค ํด๋ฌ์คํฐ์ ๋ณต์ ์ํ๋ฅผ ๊ธฐ๋กํ๋๋ฐ ์ฌ์ฉ๋ฉ๋๋ค.
### Redis๋ ์ ๋น ๋ฅธ๊ฐ์?
@@ -835,7 +835,7 @@ Redis๋ ๋ค์ด์ด๊ทธ๋จ์ ํ์๋ ๊ฒ์ฒ๋ผ ๋ค์ํ ์๋๋ฆฌ์ค์์ ์ฌ
- CDN (Content Delivery Network): CDN์ ๋ ๋น ๋ฅธ ์ ์ก์ ์ํด ์ ์ ์ฝํ
์ธ ๋ฅผ ๋ณด๊ดํ๋ ์ง๋ฆฌ์ ์ผ๋ก ๋ถ์ฐ๋ ์๋ฒ ๊ทธ๋ฃน์
๋๋ค. ํด๋ผ์ด์ธํธ๋ ๋จผ์ CDN์์ ์ฝํ
์ธ ๋ฅผ ์ฐพ์ ๋ค์ ๋ฐฑ์๋ ์๋น์ค๋ก ์ด๋ํฉ๋๋ค.
- API Gateway: ์์ ์์ฒญ์ ์ฒ๋ฆฌํ๊ณ ๊ด๋ จ ์๋น์ค๋ก ๋ผ์ฐํ
ํฉ๋๋ค. ID ๊ณต๊ธ์์ ํต์ ํ๊ณ ์๋น์ค๋ฅผ ๊ฒ์ํฉ๋๋ค.
- Identity Provider: ์ฌ์ฉ์์ ๋ํ ์ธ์ฆ๊ณผ ์ธ๊ฐ๋ฅผ ์ฒ๋ฆฌํฉ๋๋ค.
-- Service Registry & Discovery: ์ด ์ปดํฌ๋ํธ์์ ๋ง์ดํฌ๋ก์๋น์ค ๋ฑ๋ก ๋ฐ ๊ฒ์์ด ์ด๋ฃจ์ด์ง๊ณ , API ๊ฒ์ดํธ์จ์ด๋ ์ด ์ปดํฌ๋ํธ์์ ๋ํํ ๊ด๋ จ ์๋น์ค๋ฅผ ์ฐพ์ต๋๋ค.
+- Service Registry & Discovery: ์ด ์ปดํฌ๋ํธ์์ ๋ง์ดํฌ๋ก์๋น์ค ๋ฑ๋ก ๋ฐ ๊ฒ์์ด ์ด๋ฃจ์ด์ง๊ณ , API ๊ฒ์ดํธ์จ์ด๋ ์ด ์ปดํฌ๋ํธ์์ ํต์ ํ ๊ด๋ จ ์๋น์ค๋ฅผ ์ฐพ์ต๋๋ค.
- Management: ์ด ์ปดํฌ๋ํธ๋ ์๋น์ค ๋ชจ๋ํฐ๋ง์ ๋ด๋นํฉ๋๋ค.
- Microservices: ๋ง์ดํฌ๋ก์๋น์ค๋ ์๋ก ๋ค๋ฅธ ๋๋ฉ์ธ์์ ์ค๊ณ ๋ฐ ๋ฐฐํฌ๋ฉ๋๋ค. ๊ฐ ๋๋ฉ์ธ์๋ ์์ฒด ๋ฐ์ดํฐ๋ฒ ์ด์ค๊ฐ ์์ต๋๋ค. API ๊ฒ์ดํธ์จ์ด๋ REST API ๋๋ ๊ธฐํ ํ๋กํ ์ฝ์ ํตํด ๋ง์ดํฌ๋ก์๋น์ค์ ํต์ ํ๊ณ , ๋์ผํ ๋๋ฉ์ธ ๋ด์ ๋ง์ดํฌ๋ก์๋น์ค๋ RPC(Remote Procedure Call)๋ฅผ ์ฌ์ฉํ์ฌ ์๋ก ํต์ ํฉ๋๋ค.
@@ -847,7 +847,7 @@ Redis๋ ๋ค์ด์ด๊ทธ๋จ์ ํ์๋ ๊ฒ์ฒ๋ผ ๋ค์ํ ์๋๋ฆฌ์ค์์ ์ฌ
### ๋ง์ดํฌ๋ก์๋น์ค ๋ชจ๋ฒ์ฌ๋ก
-์ฌ์ง ํ ์ฅ์ด ์ฒ ๋ง๋ ๋ง๋ณด๋ค ๋ซ์ต๋๋ค: ๋ง์ดํฌ๋ก์๋น์ค ๊ฐ๋ฐ์ ์ํ 9๊ฐ์ง ๋ชจ๋ฒ ์ฌ๋ก.
+์ฌ์ง ํ ์ฅ์ด ์ฒ ๋ง๋ ๋ง๋ณด๋ค ๋ซ์ต๋๋ค. ๋ค์์ ๋ง์ดํฌ๋ก์๋น์ค ๊ฐ๋ฐ์ ์ํ 9๊ฐ์ง ๋ชจ๋ฒ ์ฌ๋ก์
๋๋ค.
@@ -857,7 +857,7 @@ Redis๋ ๋ค์ด์ด๊ทธ๋จ์ ํ์๋ ๊ฒ์ฒ๋ผ ๋ค์ํ ์๋๋ฆฌ์ค์์ ์ฌ
๋ง์ดํฌ๋ก์๋น์ค๋ฅผ ๊ฐ๋ฐํ ๋๋ ๋ค์๊ณผ ๊ฐ์ ๋ชจ๋ฒ ์ฌ๋ก๋ฅผ ๋ฐ๋ผ์ผ ํฉ๋๋ค.
1. ๊ฐ ๋ง์ดํฌ๋ก์๋น์ค๋ง๋ค ๋ณ๋์ ๋ฐ์ดํฐ ์คํ ๋ฆฌ์ง ์ฌ์ฉ
-2. ์ฝ๋์ ์์ฑ๋๋ฅผ ๋น์ทํ ์์ค์ผ๋ก ์ ์ง
+2. ์ฝ๋์ ์์ฑ๋๋ฅผ ๋น์ทํ ์์ค์ผ๋ก ์ ์ง
3. ๊ฐ ๋ง์ดํฌ๋ก์๋น์ค๋ง๋ค ๋ณ๋๋ก ๋น๋
4. ๊ฐ ๋ง์ดํฌ๋ก์๋น์ค์ ๋จ์ผ ์ฑ
์ ํ ๋น
5. ์ปจํ
์ด๋์ ๋ฐฐํฌ
@@ -879,21 +879,21 @@ Redis๋ ๋ค์ด์ด๊ทธ๋จ์ ํ์๋ ๊ฒ์ฒ๋ผ ๋ค์ํ ์๋๋ฆฌ์ค์์ ์ฌ
- Define API - ์ด๋ ๊ฒ ํ๋ฉด ํ๋ก ํธ์๋์ ๋ฐฑ์๋ ๊ฐ์ ๊ณ์ฝ์ด ์ฑ๋ฆฝ๋ฉ๋๋ค. ์ด๋ฅผ ์ํด Postman, OpenAPI๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค.
- Development - ํ๋ก ํธ์๋ ๊ฐ๋ฐ์๋ Node.js๋ react๊ฐ, ๋ฐฑ์๋ ๊ฐ๋ฐ์๋ ์๋ฐ/ํ์ด์ฌ/go๊ฐ ๋ง์ด ์ฌ์ฉ๋ฉ๋๋ค. ๋ํ API ์ ์์ ๋ฐ๋ผ API ๊ฒ์ดํธ์จ์ด์ ๊ตฌ์ฑ์ ๋ณ๊ฒฝํด์ผ ํฉ๋๋ค.
-- Continuous Integration - ์๋ํ๋ ํ
์คํธ๋ฅผ ์ํด JUnit๊ณผ Jenkins๋ฅผ ์ฌ์ฉํฉ๋๋ค. ์ฝ๋๋ Docker ์ด๋ฏธ์ง๋ก ํจํค์ง๋์ด ๋ง์ดํฌ๋ก์๋น์ค๋ก ๋ฐฐํฌ๋ฉ๋๋ค.
+- Continuous Integration - ์๋ํ๋ ํ
์คํธ๋ฅผ ์ํด JUnit๊ณผ Jenkins๋ฅผ ์ฌ์ฉํฉ๋๋ค. ์ฝ๋๋ ๋์ปค ์ด๋ฏธ์ง๋ก ํจํค์ง๋์ด ๋ง์ดํฌ๋ก์๋น์ค๋ก ๋ฐฐํฌ๋ฉ๋๋ค.
โถ๏ธ ๐๐ซ๐จ๐๐ฎ๐๐ญ๐ข๐จ๐ง
- ๋ก๋ ๋ฐธ๋ฐ์์๋ NGinx๊ฐ ์ผ๋ฐ์ ์ผ๋ก ์ ํ๋ฉ๋๋ค. Cloudflare๋ CDN(Content Delivery Network)์ ์ ๊ณตํฉ๋๋ค.
-- API Gateway - ๊ฒ์ดํธ์จ์ด์๋ ์คํ๋ง ๋ถํธ๋ฅผ ์ฌ์ฉํ๊ณ , ์๋น์ค ๊ฒ์์๋ Eureka/Zookeeper๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค.
+- API Gateway - ๊ฒ์ดํธ์จ์ด์๋ ์คํ๋ง ๋ถํธ๋ฅผ ์ฌ์ฉํ๊ณ , ์๋น์ค ๊ฒ์์๋ ์ ๋ ์นด/์ฃผํคํผ๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค.
- ๋ง์ดํฌ๋ก์๋น์ค๋ ํด๋ผ์ฐ๋์ ๋ฐฐํฌ๋ฉ๋๋ค. AWS, Microsoft Azure, Google GCP ์ค์์ ์ ํํ ์ ์์ต๋๋ค.
-Cache and Full-text Search - Redis๋ key-value ์์ ์บ์ฑํ๊ธฐ ์ํ ์ผ๋ฐ์ ์ธ ์ ํ์
๋๋ค. ํ ํ
์คํธ ์์น์๋ Elasticsearch๊ฐ ์ฌ์ฉ๋ฉ๋๋ค.
-- Communications - ์๋น์ค๊ฐ ์๋ก ํต์ ํ๊ธฐ ์ํด์๋ ๋ฉ์์ง ์ธํ๋ผ๋ก Kafka ํน์ RPC๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค.
+Cache and Full-text Search - Redis๋ key-value ์์ ์บ์ฑํ๊ธฐ ์ํ ์ผ๋ฐ์ ์ธ ์ ํ์
๋๋ค. ํํ
์คํธ ๊ฒ์์๋ Elasticsearch๊ฐ ์ฌ์ฉ๋ฉ๋๋ค.
+- Communications - ์๋น์ค๊ฐ ์๋ก ํต์ ํ๊ธฐ ์ํด์๋ ๋ฉ์์ง ์ธํ๋ผ๋ก ์นดํ์นด ํน์ RPC๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค.
- Persistence - ๊ด๊ณํ ๋ฐ์ดํฐ๋ฒ ์ด์ค์๋ MySQL ๋๋ PostgreSQL์ ์ฌ์ฉํ ์ ์์ผ๋ฉฐ, ๊ฐ์ฒด ์คํ ๋ฆฌ์ง์๋ Amazon S3์ ์ฌ์ฉํ ์ ์์ต๋๋ค. ํ์ํ ๊ฒฝ์ฐ wide-column ์คํ ๋ฆฌ์ง๋ก Cassandra๋ฅผ ์ฌ์ฉํ ์๋ ์์ต๋๋ค.
- Management & Monitoring - ์๋ง์ ๋ง์ดํฌ๋ก์๋น์ค๋ฅผ ๊ด๋ฆฌํ๊ธฐ ์ํ ์ผ๋ฐ์ ์ธ ์ด์ ๋๊ตฌ๋ก Prometheus, Elastic Stack, Kubernetes๊ฐ ์์ต๋๋ค.
### ์นดํ์นด๊ฐ ๋น ๋ฅธ ์ด์
-์นดํ์นด์ ์ฑ๋ฅ์ ๊ธฐ์ฌํ ๋ง์ ๋์์ธ ๊ฒฐ์ ์ด ์์ต๋๋ค. ์ด ๊ธ์์๋ ๋ ๊ฐ์ง์ ์ด์ ์ ๋ง์ถ๊ฒ ์ต๋๋ค. ์ด ๋ ๊ฐ์ง๊ฐ ๊ฐ์ฅ ํฐ ๋น์ค์ ์ฐจ์งํ๋ค๊ณ ์๊ฐํฉ๋๋ค.
+์นดํ์นด ์ฑ๋ฅ์ ๊ธฐ์ฌํ ๋ง์ ๋์์ธ ๊ฒฐ์ ์ด ์์ต๋๋ค. ์ด ๊ธ์์๋ ๋ ๊ฐ์ง์ ์ด์ ์ ๋ง์ถ๊ฒ ์ต๋๋ค. ์ด ๋ ๊ฐ์ง๊ฐ ๊ฐ์ฅ ํฐ ๋น์ค์ ์ฐจ์งํ๋ค๊ณ ์๊ฐํฉ๋๋ค.
@@ -958,7 +958,7 @@ Cache and Full-text Search - Redis๋ key-value ์์ ์บ์ฑํ๊ธฐ ์ํ ์ผ
- ์นด๋ ์์ ์ฃผ๊ฐ ๋ฐ๊ธ์ฌ์ ๋๊ธ์ ์ง๋ถํ์ง ์๋๋ผ๋ ๋ฐ๊ธ์ฌ๋ ํ๋งค์์๊ฒ ๋๊ธ์ ์ง๋ถํฉ๋๋ค.
- ์นด๋ ์์ง์๊ฐ ๋ฐ๊ธ์ฌ์ ๋๊ธ์ ์ง๋ถํ๊ธฐ ์ ์ ๋ฐ๊ธ์ฌ๊ฐ ํ๋งค์์๊ฒ ๋๊ธ์ ๋จผ์ ์ง๋ถํฉ๋๋ค.
-- ๋ฐํ์ฌ๋ ๊ณ ๊ฐ ๊ณ์ข ๊ด๋ฆฌ, ๋ช
์ธ์ ์ ๊ณต, ์ฌ๊ธฐ ํ์ง, ์ํ ๊ด๋ฆฌ, ์ฒญ์ฐ ๋ฐ ๊ฒฐ์ ๋ฑ ๊ธฐํ ์ด์ ๋น์ฉ์ด ๋ฐ์ํฉ๋๋ค.
+- ๋ฐ๊ธ์ฌ๋ ๊ณ ๊ฐ ๊ณ์ข ๊ด๋ฆฌ, ๋ช
์ธ์ ์ ๊ณต, ์ฌ๊ธฐ ํ์ง, ์ํ ๊ด๋ฆฌ, ์ฒญ์ฐ ๋ฐ ๊ฒฐ์ ๋ฑ ๊ธฐํ ์ด์ ๋น์ฉ์ด ๋ฐ์ํฉ๋๋ค.
### ์์ ์์ ์ฐ๋ฆฌ๊ฐ ์ ์ฉ์นด๋๋ฅผ ๊ธ์ ๋, VISA๋ ์ด๋ป๊ฒ ์๋ํ๋์?
@@ -969,7 +969,7 @@ Cache and Full-text Search - Redis๋ key-value ์์ ์บ์ฑํ๊ธฐ ์ํ ์ผ
๋น์, ๋ง์คํฐ์นด๋, ์๋ฉ๋ฆฌ์นธ ์ต์คํ๋ ์ค๋ ์๊ธ ์ฒญ์ฐ ๋ฐ ์ ์ฐ์ ์ํ ์นด๋ ๋คํธ์ํฌ ์ญํ ์ ํฉ๋๋ค. ์นด๋ ๋งค์
์ํ๊ณผ ์นด๋ ๋ฐ๊ธ ์ํ์ ์๋ก ๋ค๋ฅผ ์ ์์ผ๋ฉฐ, ์ค์ ๋ก๋ ์ข
์ข
๋ค๋ฆ
๋๋ค. ์ํ์ด ์ค๊ฐ์ ์์ด ํ๋์ฉ ๊ฑฐ๋๋ฅผ ์ ์ฐํ๋ค๋ฉด, ๊ฐ ์ํ์ ๋ค๋ฅธ ๋ชจ๋ ์ํ๊ณผ ๊ฑฐ๋๋ฅผ ์ ์ฐํด์ผ ํฉ๋๋ค. ์ด๋ ๋งค์ฐ ๋นํจ์จ์ ์
๋๋ค.
-์๋ ๋ค์ด์ด๊ทธ๋จ์ ์ ์ฉ ์นด๋ ๊ฒฐ์ ํ๋ก์ธ์ค์์ VISA์ ์ญํ ์ ๋ณด์ฌ์ค๋๋ค. ๋ ๊ฐ์ง ํ๋ก์ฐ๊ฐ ๊ด๋ จ๋์ด ์์ต๋๋ค. ์น์ธ ํ๋ฆ์ ๊ณ ๊ฐ์ด ์ ์ฉ์นด๋๋ฅผ ์ค์์ดํํ ๋ ๋ฐ์ํฉ๋๋ค. ์บก์ฒ์ ์ ์ฐ ํ๋ก์ฐ๋ ์์ ์ด ํ๋ฃจ๊ฐ ๋๋ ๋ ๋ฐ์ํฉ๋๋ค.
+์ ๋ค์ด์ด๊ทธ๋จ์ ์ ์ฉ ์นด๋ ๊ฒฐ์ ํ๋ก์ธ์ค์์ VISA์ ์ญํ ์ ๋ณด์ฌ์ค๋๋ค. ๋ ๊ฐ์ง ํ๋ก์ฐ๊ฐ ๊ด๋ จ๋์ด ์์ต๋๋ค. ์น์ธ ํ๋ฆ์ ๊ณ ๊ฐ์ด ์ ์ฉ์นด๋๋ฅผ ์ค์์ดํํ ๋ ๋ฐ์ํฉ๋๋ค. ์บก์ฒ์ ์ ์ฐ ํ๋ก์ฐ๋ ์์ ์ด ํ๋ฃจ๊ฐ ๋๋ ๋ ๋ฐ์ํฉ๋๋ค.
- ๊ฑฐ๋ ์น์ธ ํ๋ก์ฐAuthorization Flow
@@ -981,7 +981,7 @@ Cache and Full-text Search - Redis๋ key-value ์์ ์บ์ฑํ๊ธฐ ์ํ ์ผ
3, 4๋จ๊ณ: ๋งค์
์ํ์ ๊ฑฐ๋๋ฅผ ์นด๋ ๋คํธ์ํฌ๋ก ์ ์กํ๋ฉฐ, ์ด๋ฅผ ์นด๋ ์คํด์ด๋ผ๊ณ ๋ ํฉ๋๋ค. ์นด๋ ๋คํธ์ํฌ๋ ์น์ธ์ ์ํด ๋ฐ๊ธ ์ํ์ผ๋ก ๊ฑฐ๋๋ฅผ ์ ์กํฉ๋๋ค.
-4.1, 4.2, 4.3๋จ๊ณ: ํธ๋์ญ์
์ด ์น์ธ๋๋ฉด ๋ฐํ ์ํ์ ์๊ธ์ ๋๊ฒฐํฉ๋๋ค. ์น์ธ ๋๋ ๊ฑฐ๋ถ๊ฐ ๋งค์
์ํ์๊ฒ ๋ค์ ์ ์ก๋๊ณ POS ๋จ๋ง๊ธฐ๋ก๋ ์ ์ก๋ฉ๋๋ค.
+4.1, 4.2, 4.3๋จ๊ณ: ํธ๋์ญ์
์ด ์น์ธ๋๋ฉด ๋ฐ๊ธ ์ํ์ ์๊ธ์ ๋๊ฒฐํฉ๋๋ค. ์น์ธ ๋๋ ๊ฑฐ๋ถ๊ฐ ๋งค์
์ํ์ ๋ค์ ์ ์ก๋๊ณ POS ๋จ๋ง๊ธฐ๋ก๋ ์ ์ก๋ฉ๋๋ค.
- ์บก์ฒ์ ์ ์ฐ ํ๋ก์ฐCapture and Settlement Flow
@@ -989,7 +989,7 @@ Cache and Full-text Search - Redis๋ key-value ์์ ์บ์ฑํ๊ธฐ ์ํ ์ผ
3๋จ๊ณ: ์นด๋ ๋คํธ์ํฌ๋ ์ฌ๋ฌ ๋งค์
์ํ์ผ๋ก๋ถํฐ ์์งํ ๊ฑฐ๋์ ๋ํด ์ ์ฐ์ ์ํํ๊ณ ์ ์ฐ ํ์ผ์ ์ฌ๋ฌ ๋ฐ๊ธ ์ํ์ผ๋ก ์ ์กํฉ๋๋ค.
-4๋จ๊ณ: ๋ฐํ ์ํ์ ์ ์ฐ ํ์ผ์ ์ ํ์ฑ์ ํ์ธํ๊ณ ๊ด๋ จ ๋งค์
์ํ์ผ๋ก ์๊ธ์ ์ด์ฒดํฉ๋๋ค.
+4๋จ๊ณ: ๋ฐ๊ธ ์ํ์ ์ ์ฐ ํ์ผ์ ์ ํ์ฑ์ ํ์ธํ๊ณ ๊ด๋ จ ๋งค์
์ํ์ผ๋ก ์๊ธ์ ์ด์ฒดํฉ๋๋ค.
5๋จ๊ณ: ๊ทธ๋ฌ๋ฉด ๋งค์
์ํ์ด ํ๋งค์์ ์ํ์ผ๋ก ์ก๊ธํฉ๋๋ค.
@@ -1032,7 +1032,7 @@ SRE(Site Reliability Engineering)๋ 2000๋
๋ ์ด๋ฐ ๊ตฌ๊ธ์์ ๋๊ท๋ชจ
### k8s(Kubernetes)๋ ๋ฌด์์ธ๊ฐ์?
-K8s๋ ์ปจํ
์ด๋ ์ค์ผ์คํธ๋ ์ด์
์์คํ
์
๋๋ค. ์ปจํ
์ด๋ ๋ฐฐํฌ ๋ฐ ๊ด๋ฆฌ์ ์ฌ์ฉ๋ฉ๋๋ค. ์ด ์์คํ
์ ์ค๊ณ๋ Google์ ๋ด๋ถ ์์คํ
์ธ Borg์ ์ํฅ์ ๋ง์ด ๋ฐ์์ต๋๋ค.
+K8s๋ ์ปจํ
์ด๋ ์ค์ผ์คํธ๋ ์ด์
์์คํ
์
๋๋ค. ์ปจํ
์ด๋ ๋ฐฐํฌ ๋ฐ ๊ด๋ฆฌ์ ์ฌ์ฉ๋ฉ๋๋ค. ์ด ์์คํ
์ ์ค๊ณ๋ ๊ตฌ๊ธ์ ๋ด๋ถ ์์คํ
์ธ Borg์ ์ํฅ์ ๋ง์ด ๋ฐ์์ต๋๋ค.
@@ -1058,17 +1058,17 @@ k8s ํด๋ฌ์คํฐ๋ ์ปจํ
์ด๋ํ๋ ์ ํ๋ฆฌ์ผ์ด์
์ ์คํํ๋ ๋
ธ๋
4. Etcd
- etcd๋ ๋ชจ๋ ํด๋ฌ์คํฐ ๋ฐ์ดํฐ์ ๋ํ ์ฟ ๋ฒ๋คํฐ์ค์ ๋ฐฑ์
์คํ ๋ฆฌ์ง๋ก ์ฌ์ฉ๋๋ ํค-๋ฐธ๋ฅ ์คํ ๋ฆฌ์ง์
๋๋ค.
+ etcd๋ ๋ชจ๋ ํด๋ฌ์คํฐ ๋ฐ์ดํฐ์ ๋ํ ์ฟ ๋ฒ๋คํฐ์ค์ ๋ฐฑ์
์คํ ๋ฆฌ์ง๋ก ์ฌ์ฉ๋๋ key-value ์คํ ๋ฆฌ์ง์
๋๋ค.
- Nodes
-1. Pods
+1. Pod
- ํ๋๋ ์ปจํ
์ด๋ ๊ทธ๋ฃน์ผ๋ก, k8์ด ๊ด๋ฆฌํ๋ ๊ฐ์ฅ ์์ ๋จ์์
๋๋ค. ํ๋์๋ ํ๋ ๋ด์ ๋ชจ๋ ์ปจํ
์ด๋์ ๋จ์ผ IP ์ฃผ์๊ฐ ์ ์ฉ๋ฉ๋๋ค.
+ ํ๋๋ ์ปจํ
์ด๋ ๊ทธ๋ฃน์ผ๋ก, k8s๊ฐ ๊ด๋ฆฌํ๋ ๊ฐ์ฅ ์์ ๋จ์์
๋๋ค. ํ๋์๋ ํ๋ ๋ด์ ๋ชจ๋ ์ปจํ
์ด๋์ ๋จ์ผ IP ์ฃผ์๊ฐ ์ ์ฉ๋ฉ๋๋ค.
2. Kubelet
- ํด๋ฌ์คํฐ์ ๊ฐ ๋
ธ๋์์ ์คํ๋๋ ์์ด์ ํธ. ์ปจํ
์ด๋๊ฐ ํ๋์์ ์คํ๋๋๋ก ๋ณด์ฅํฉ๋๋ค.
+ ํด๋ฌ์คํฐ์ ๊ฐ ๋
ธ๋์์ ์คํ๋๋ ์์ด์ ํธ์
๋๋ค. ์ปจํ
์ด๋๊ฐ ํ๋์์ ์คํ๋๋๋ก ๋ณด์ฅํฉ๋๋ค.
3. Kube Proxy
@@ -1083,7 +1083,7 @@ k8s ํด๋ฌ์คํฐ๋ ์ปจํ
์ด๋ํ๋ ์ ํ๋ฆฌ์ผ์ด์
์ ์คํํ๋ ๋
ธ๋
๋์ปคDocker๋ ๋ฌด์์ธ๊ฐ์?
-Docker๋ ๊ฒฉ๋ฆฌ๋ ์ปจํ
์ด๋์์ ์ ํ๋ฆฌ์ผ์ด์
์ ํจํค์ง, ๋ฐฐํฌ ๋ฐ ์คํํ ์ ์๋ ์คํ ์์ค ํ๋ซํผ์
๋๋ค. ์ปจํ
์ด๋ํ์ ์ค์ ์ ๋์ด ์ ํ๋ฆฌ์ผ์ด์
๊ณผ ๊ทธ ์ข
์์ฑ์ ์บก์ํํ๋ ๊ฒฝ๋ ํ๊ฒฝ์ ์ ๊ณตํฉ๋๋ค.
+๋์ปค๋ ๊ฒฉ๋ฆฌ๋ ์ปจํ
์ด๋์์ ์ ํ๋ฆฌ์ผ์ด์
์ ํจํค์ง, ๋ฐฐํฌ ๋ฐ ์คํํ ์ ์๋ ์คํ ์์ค ํ๋ซํผ์
๋๋ค. ์ปจํ
์ด๋ํ์ ์ค์ ์ ๋์ด ์ ํ๋ฆฌ์ผ์ด์
๊ณผ ๊ทธ ์ข
์์ฑ์ ์บก์ํํ๋ ๊ฒฝ๋ ํ๊ฒฝ์ ์ ๊ณตํฉ๋๋ค.
Kubernetes๋ ๋ฌด์์ธ๊ฐ์?
@@ -1133,7 +1133,7 @@ Kubernetes: ์ฟ ๋ฒ๋คํฐ์ค๋ ํด๋ฌ์คํฐ ๋ ๋ฒจ์์ ์๋ํฉ๋๋ค. ์ฌ๋ฌ
### Git Commands ์๋ ๋ฐฉ์
-์ฐ์ ์ฝ๋๊ฐ ์ด๋์ ์ ์ฅ๋์ด ์๋์ง ํ์
ํ๋ ๊ฒ์ด ์ค์ํฉ๋๋ค. ์ผ๋ฐ์ ์ผ๋ก ์ฝ๋๊ฐ ์ ์ฅ๋๋ ์์น๋ Github๊ณผ ๊ฐ์ ๋ฆฌ๋ชจํธ ์๋ฒ์ ๋ก์ปฌ ์ปดํจํฐ ๋ ๊ณณ๋ฟ์ด๋ผ๊ณ ๊ฐ์ ํฉ๋๋ค. ํ์ง๋ง ์ด๋ ์ ํํ์ง ์์ต๋๋ค. Git์ ์ปดํจํฐ์ 3๊ฐ์ ๋ก์ปฌ ์ ์ฅ์๋ฅผ ์ ์งํ๋ฏ๋ก ์ฝ๋๊ฐ ๋ค ๊ณณ์์ ๋ฐ๊ฒฌ๋ ์ ์์ต๋๋ค.
+์ฐ์ ์ฝ๋๊ฐ ์ด๋์ ์ ์ฅ๋์ด ์๋์ง ํ์
ํ๋ ๊ฒ์ด ์ค์ํฉ๋๋ค. ์ผ๋ฐ์ ์ผ๋ก ์ฝ๋๊ฐ ์ ์ฅ๋๋ ์์น๋ Github๊ณผ ๊ฐ์ ๋ฆฌ๋ชจํธ ์๋ฒ์ ๋ก์ปฌ ์ปดํจํฐ ๋ ๊ณณ ๋ฟ์ด๋ผ๊ณ ๊ฐ์ ํฉ๋๋ค. ํ์ง๋ง ์ด๋ ์ ํํ์ง ์์ต๋๋ค. Git์ ์ปดํจํฐ์ 3๊ฐ์ ๋ก์ปฌ ์ ์ฅ์๋ฅผ ์ ์งํ๋ฏ๋ก ์ฝ๋๊ฐ ๋ค ๊ณณ์์ ๋ฐ๊ฒฌ๋ ์ ์์ต๋๋ค.
@@ -1173,13 +1173,13 @@ Git์ ๋ถ์ฐ ๋ฒ์ ๊ด๋ฆฌ ์์คํ
์
๋๋ค.
-ํ Git ๋ธ๋์น์์ ๋ค๋ฅธ ๋ธ๋์น๋ก **merge changes** ํ ๋ 'git merge' ๋๋ 'git rebase'๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค. ์๋ ๋ค์ด์ด๊ทธ๋จ์ ๋ ์ปค๋งจ๋์ ์๋ ๋ฐฉ์์ ๋ณด์ฌ์ค๋๋ค.
+ํ Git ๋ธ๋์น์์ ๋ค๋ฅธ ๋ธ๋์น๋ก **merge changes** ํ ๋ git merge ๋๋ git rebase๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค. ์๋ ๋ค์ด์ด๊ทธ๋จ์ ๋ ์ปค๋งจ๋์ ์๋ ๋ฐฉ์์ ๋ณด์ฌ์ค๋๋ค.
**Git merge**
-๊ทธ๋ฌ๋ฉด ๋ฉ์ธ ๋ธ๋์น์ ์ ์ปค๋ฐ G'๊ฐ ๋ง๋ค์ด์ง๋๋ค. G'๋ ๋ฉ์ธ ๋ธ๋์น์ ํผ์ฒ ๋ธ๋์น์ ํ์คํ ๋ฆฌ๋ฅผ ๋ชจ๋ ์ฐ๊ฒฐํฉ๋๋ค.
+์ด ์์
์ ๋ฉ์ธ ๋ธ๋์น์ ์ ์ปค๋ฐ G'๋ฅผ ์์ฑํฉ๋๋ค. G'๋ ๋ฉ์ธ ๋ธ๋์น์ ํผ์ฒ ๋ธ๋์น์ ํ์คํ ๋ฆฌ๋ฅผ ๋ชจ๋ ์ฐ๊ฒฐํฉ๋๋ค.
-Git ๋ณํฉ์ **non-destructive**์ด๋ค. ๋ฉ์ธ ๋ธ๋์น๋ ํผ์ฒ ๋ธ๋์น ๋ชจ๋ ๋ณ๊ฒฝ๋์ง ์๋๋ค.
+Git ๋ณํฉ์ **non-destructive**์
๋๋ค. ๋ฉ์ธ ๋ธ๋์น๋ ํผ์ฒ ๋ธ๋์น ๋ชจ๋ ๋ณ๊ฒฝ๋์ง ์์ต๋๋ค.
**Git rebase**
@@ -1187,9 +1187,9 @@ Git ๋ฆฌ๋ฒ ์ด์ค๋ ํผ์ฒ ๋ธ๋์น ํ์คํ ๋ฆฌ๋ฅผ ๋ฉ์ธ ๋ธ๋์น์ ํค๋
๋ฆฌ๋ฒ ์ด์ค์ ์ฅ์ ์ ์ ํ์ ์ธ **commit history**๊ฐ ์๋ค๋ ๊ฒ์
๋๋ค.
-"git ๋ฆฌ๋ฒ ์ด์ค์ ํฉ๊ธ๋ฅ "์ ๋ฐ๋ฅด์ง ์์ผ๋ฉด ๋ฆฌ๋ฒ ์ด์ค๊ฐ ์ํํ ์ ์์ต๋๋ค.
+"git ๋ฆฌ๋ฒ ์ด์ค ํฉ๊ธ๋ฅ "์ ๋ฐ๋ฅด์ง ์์ผ๋ฉด ๋ฆฌ๋ฒ ์ด์ค๊ฐ ์ํํ ์ ์์ต๋๋ค.
-**The Golden Rule of Git Rebase**
+**git ๋ฆฌ๋ฒ ์ด์ค ํฉ๊ธ๋ฅ **
ํผ๋ธ๋ ๋ธ๋์น์์๋ ์ ๋ ์ฌ์ฉํ์ง ๋ง์ธ์!
@@ -1217,13 +1217,12 @@ Git ๋ฆฌ๋ฒ ์ด์ค๋ ํผ์ฒ ๋ธ๋์น ํ์คํ ๋ฆฌ๋ฅผ ๋ฉ์ธ ๋ธ๋์น์ ํค๋
ํด๋ผ์ฐ๋ ๋ค์ดํฐ๋ธ์๋ 4๊ฐ์ง ์ธก๋ฉด์ด ์์ต๋๋ค.
1. Development process
-
- This has progressed from waterfall to agile to DevOps.
+
์ํฐํด์์ ์ ์์ผ, ๋ฐ๋ธ์ต์ค๋ก ๋ฐ์ ํด ์์ต๋๋ค.
2. Application Architecture
- ์ํคํ
์ฒ๊ฐ ๋ชจ๋๋ฆฌ์ ์๋น์ค์์ ๋ง์ดํฌ๋ก ์๋น์ค๋ก ๋ฐ๋์์ต๋๋ค. ๊ฐ ์๋น์ค๋ ํด๋ผ์ฐ๋ ์ปจํ
์ด๋์ ์ ํ๋ ๋ฆฌ์์ค์ ๋ง๊ฒ ์๊ท๋ชจ๋ก ์กฐ์ ๋๋๋ก ์ค๊ณ๋์์ต๋๋ค.
+ ์ํคํ
์ฒ๊ฐ ๋ชจ๋๋ฆฌ์ ์๋น์ค์์ ๋ง์ดํฌ๋ก์๋น์ค๋ก ๋ฐ๋์์ต๋๋ค. ๊ฐ ์๋น์ค๋ ํด๋ผ์ฐ๋ ์ปจํ
์ด๋์ ์ ํ๋ ๋ฆฌ์์ค์ ๋ง๊ฒ ์๊ท๋ชจ๋ก ์กฐ์ ๋๋๋ก ์ค๊ณ๋์์ต๋๋ค.
3. Deployment & packaging
@@ -1258,7 +1257,7 @@ JSON ํ์ผ์์ ๊ทธ๋ํ ๋ค์ด์ด๊ทธ๋จ์ ์์ฑํ๊ณ ์ฝ๊ฒ ์ฝ์ ์
์ด๋ค ๊ธฐ๋ฅ์ด ์๋์?
- Python ์ฝ๋๋ก ํด๋ผ์ฐ๋ ์์คํ
์ํคํ
์ฒ๋ฅผ ๊ทธ๋ฆฝ๋๋ค.
-- ๋ค์ด์ด๊ทธ๋จ์ ์ฃผํผํฐ ๋
ธํธ๋ถ์์ ๋ฐ๋ก ๋ ๋๋งํ ์๋ ์์ต๋๋ค.
+- ๋ค์ด์ด๊ทธ๋จ์ ์ฃผํผํฐ ๋
ธํธ๋ถ์์ ๋ฐ๋ก ๋ ๋๋งํ ์ ์์ต๋๋ค.
- ๋์์ธ ๋๊ตฌ๊ฐ ํ์ํ์ง ์์ต๋๋ค.
- ๋ค์ ํ๋ก๋ฐ์ด๋๋ฅผ ์ง์ํฉ๋๋ค: AWS, Azure, GCP, Kubernetes, ์๋ฆฌ๋ฐ๋ฐ ํด๋ผ์ฐ๋, ์ค๋ผํด ํด๋ผ์ฐ๋ ๋ฑ.
@@ -1279,7 +1278,7 @@ JSON ํ์ผ์์ ๊ทธ๋ํ ๋ค์ด์ด๊ทธ๋จ์ ์์ฑํ๊ณ ์ฝ๊ฒ ์ฝ์ ์
### ๊ฐ์ฅ ๋ง์ด ์ฌ์ฉ๋๋ 18๊ฐ์ง ๋ฆฌ๋
์ค ์ปค๋งจ๋ ์์๋ณด๊ธฐ
-Linux ์ปค๋งจ๋๋ ์ด์ ์ฒด์ ์ ์ํธ ์์ฉํ๊ธฐ ์ํ ์ธ์คํฐ๋ญ์
์
๋๋ค. ํ์ผ, ๋๋ ํ ๋ฆฌ, ์์คํ
ํ๋ก์ธ์ค ๋ฐ ๊ธฐํ ์์คํ
์ ์ฌ๋ฌ ์ธก๋ฉด์ ๊ด๋ฆฌํ๋ ๋ฐ ๋์์ด ๋ฉ๋๋ค. Linux ๊ธฐ๋ฐ ์์คํ
์ ํจ์จ์ ์ด๊ณ ํจ๊ณผ์ ์ผ๋ก ํ์ํ๊ณ ์ ์ง ๊ด๋ฆฌํ๋ ค๋ฉด ์ด๋ฌํ ์ปค๋งจ๋์ ์ต์ํด์ ธ์ผ ํฉ๋๋ค.
+Linux ์ปค๋งจ๋๋ ์ด์ ์ฒด์ ์ ์ํธ ์์ฉํ๊ธฐ ์ํ ์ธ์คํฐ๋ญ์
์
๋๋ค. ํ์ผ, ๋๋ ํ ๋ฆฌ, ์์คํ
ํ๋ก์ธ์ค, ๊ธฐํ ์์คํ
์ ์ฌ๋ฌ ์ธก๋ฉด์ ๊ด๋ฆฌํ๋ ๋ฐ ๋์์ด ๋ฉ๋๋ค. Linux ๊ธฐ๋ฐ ์์คํ
์ ํจ์จ์ ์ด๊ณ ํจ๊ณผ์ ์ผ๋ก ํ์ํ๊ณ ์ ์ง ๊ด๋ฆฌํ๋ ค๋ฉด ์ด๋ฌํ ์ปค๋งจ๋์ ์ต์ํด์ ธ์ผ ํฉ๋๋ค.
์๋ ๋ค์ด์ด๊ทธ๋จ์ ์์ฃผ ์ฌ์ฉ๋๋ Linux ์ปค๋งจ๋์
๋๋ค.
@@ -1300,7 +1299,7 @@ Linux ์ปค๋งจ๋๋ ์ด์ ์ฒด์ ์ ์ํธ ์์ฉํ๊ธฐ ์ํ ์ธ์คํฐ๋ญ์
- tar - tarball ์์นด์ด๋ธ ํ์ผ ์กฐ์
- vi - ํ
์คํธ ์๋ํฐ๋ฅผ ์ฌ์ฉํ์ฌ ํ์ผ ํธ์ง
- cat - ํ์ผ์ ์ฝํ
์ธ ํ์
-- top - ํ๋ก์ธ์ค ๋ฆฌ์์ค ์ฌ์ฉ๋ ํ์
+- top - ํ๋ก์ธ์ค ๋ฆฌ์์ค ์ฌ์ฉ๋ ํ์
- ps - ํ๋ก์ธ์ ์ ๋ณด ํ์
- kill - ์ ํธ๋ฅผ ์ ์กํ์ฌ ํ๋ก์ธ์ค ์ข
๋ฃ
- du - ํ์ผ ์ฉ๋ ์ฌ์ฉ๋ ์ถ์
@@ -1344,13 +1343,13 @@ OAuth 2.0์ ๊ฐ๋ ฅํ๊ณ ์์ ํ ํ๋ ์์ํฌ๋ก, ์ฌ๋ฌ ์ ํ๋ฆฌ์ผ์ด
-OAuth์ ์ฐธ์ฌํ๋ ๊ฐ์ฒด๋ ์ฌ์ฉ์, ์๋ฒ, ID ๊ณต๊ธ์(Identity Provider, IDP)์
๋๋ค.
+OAuth์ ์ฐธ์ฌํ๋ ๊ฐ์ฒด๋ ์ฌ์ฉ์, ์๋ฒ, ID ๊ณต๊ธ์(Identity Provider, IDP)์
๋๋ค.
OAuth ํ ํฐ์ ๋ฌด์์ ํ ์ ์๋์?
OAuth๋ฅผ ์ฌ์ฉํ๋ฉด ์ ์ ๋ฐ ๊ถํ์ ๋ํ๋ด๋ OAuth ํ ํฐ์ ๋ฐ๊ฒ ๋ฉ๋๋ค. ์ด ํ ํฐ์ ๋ช ๊ฐ์ง ์ค์ํ ์์
์ ์ํํ ์ ์์ต๋๋ค.
-Single Sign-On(SSO): OAuth ํ ํฐ์ ์ฌ์ฉํ๋ฉด ํ ๋ฒ์ ๋ก๊ทธ์ธ์ผ๋ก ์ฌ๋ฌ ์๋น์ค๋ ์ฑ์ ๋ก๊ทธ์ธํ ์ ์์ด ๋์ฑ ์ฝ๊ณ ์์ ํ๊ฒ ์ํํ ์ ์์ต๋๋ค.
+Single Sign-On(SSO): OAuth ํ ํฐ์ ์ฌ์ฉํ๋ฉด ํ ๋ฒ์ ๋ก๊ทธ์ธ์ผ๋ก ์ฌ๋ฌ ์๋น์ค๋ ์ฑ์ ๋ก๊ทธ์ธํ ์ ์์ด ๋์ฑ ์ฝ๊ณ ์์ ํ๊ฒ ์ํํ ์ ์์ต๋๋ค.
Authorization Across Systems: ์์คํ
๊ฐ ์ธ์ฆ: OAuth ํ ํฐ์ ์ฌ์ฉํ๋ฉด ๋ค์ํ ์์คํ
์์ ์ธ์ฆ ๋๋ ์ก์ธ์ค ๊ถํ์ ๊ณต์ ํ ์ ์์ผ๋ฏ๋ก ๋ชจ๋ ์์คํ
์์ ๋ณ๋๋ก ๋ก๊ทธ์ธํ ํ์๊ฐ ์์ต๋๋ค.
@@ -1366,7 +1365,7 @@ OAuth 2.0์ ์ฌ์ฉ์์ ์ฌ์ฉ์์ ๋ฐ์ดํฐ๋ฅผ ์์ ํ๊ฒ ๋ณดํธํ๋
1. SSH Keys:
- ์ํธํ ํค๋ ์๊ฒฉ ์์คํ
๋ฐ ์๋ฒ์ ์์ ํ๊ฒ ์ก์ธ์คํ๋ ๋ฐ ์ฌ์ฉ๋ฉ๋๋ค.
+ ์ํธํ ํค๋ ์๊ฒฉ ์์คํ
๋ฐ ์๋ฒ์ ์์ ํ๊ฒ ์ก์ธ์คํ๋๋ฐ ์ฌ์ฉ๋ฉ๋๋ค.
1. OAuth Tokens:
@@ -1409,13 +1408,13 @@ OAuth 2.0์ ์ฌ์ฉ์์ ์ฌ์ฉ์์ ๋ฐ์ดํฐ๋ฅผ ์์ ํ๊ฒ ๋ณดํธํ๋
-**ํ์ง ๋ง์์ผ ํ ๊ฒ๋ค**
+**ํ์ง ๋ง์์ผ ํ ๊ฒ๋ค**
- ๋น๋ฐ๋ฒํธ๋ฅผ ์ผ๋ฐ ํ
์คํธ๋ก ์ ์ฅํ๋ ๊ฒ์ ๋ด๋ถ ์ก์ธ์ค ๊ถํ์ด ์๋ ๋ชจ๋ ์ฌ๋์ด ๋ณผ ์ ์์ผ๋ฏ๋ก ์ข์ ์๊ฐ์ด ์๋๋๋ค.
- ๋น๋ฐ๋ฒํธ ํด์๋ฅผ ์ง์ ์ ์ฅํ๋ ๊ฒ์ ๋ ์ธ๋ณด์ฐ ํ
์ด๋ธ๊ณผ ๊ฐ์ ์ฌ์ ๊ณ์ฐ ๊ณต๊ฒฉ์ ์ทจ์ฝํ๊ธฐ ๋๋ฌธ์ ์ถฉ๋ถํ์ง ์์ต๋๋ค.
-- precomputation attacks์ ์ํํ๊ธฐ ์ํด ๋น๋ฐ๋ฒํธ๋ฅผ ์ํธ ์ฒ๋ฆฌํฉ๋๋ค.
+- ์ฌ์ ๊ณ์ฐ ๊ณต๊ฒฉ์ ์ํํ๊ธฐ ์ํด ๋น๋ฐ๋ฒํธ๋ฅผ ์ํธ ์ฒ๋ฆฌํฉ๋๋ค.
**salt๋ ๋ฌด์์ธ๊ฐ์?**
@@ -1452,9 +1451,9 @@ JWT๋ฅผ ์๋ฒ๋ก ๋ณด๋ด๋ ค๋ฉด ํค๋, ํ์ด๋ก๋, ์๋ช
์ ์์ ์์ ๋ฃ
### Google authenticator(๋๋ ๋ค๋ฅธ ์ ํ์ 2 factor authenticator)๋ ์ด๋ป๊ฒ ์๋ํ๋์?
-2๋จ๊ณ ์ธ์ฆ์ด ํ์ฑํ๋ ๊ฒฝ์ฐ ์ผ๋ฐ์ ์ผ๋ก Google ์ธ์ฆ์๊ฐ ๊ณ์ ๋ก๊ทธ์ธ์ ์ฌ์ฉ๋ฉ๋๋ค. ์ด๋ป๊ฒ ๋ณด์์ ๋ณด์ฅํ๋์?
+2๋จ๊ณ ์ธ์ฆ์ด ํ์ฑํ๋ ๊ฒฝ์ฐ ์ผ๋ฐ์ ์ผ๋ก ๊ตฌ๊ธ ์ธ์ฆ์๊ฐ ๊ณ์ ๋ก๊ทธ์ธ์ ์ฌ์ฉ๋ฉ๋๋ค. ์ด๋ป๊ฒ ๋ณด์์ ๋ณด์ฅํ๋์?
-Google ์ธ์ฆ๊ธฐ๋ 2๋จ๊ณ ์ธ์ฆ ์๋น์ค๋ฅผ ๊ตฌํํ๋ ์ํํธ์จ์ด ๊ธฐ๋ฐ ์ธ์ฆ๊ธฐ์
๋๋ค. ์๋ ๋ค์ด์ด๊ทธ๋จ์์ ์์ธํ ๋ด์ฉ์ ํ์ธํ ์ ์์ต๋๋ค.
+๊ตฌ๊ธ ์ธ์ฆ๊ธฐ๋ 2๋จ๊ณ ์ธ์ฆ ์๋น์ค๋ฅผ ๊ตฌํํ๋ ์ํํธ์จ์ด ๊ธฐ๋ฐ ์ธ์ฆ๊ธฐ์
๋๋ค. ์๋ ๋ค์ด์ด๊ทธ๋จ์์ ์์ธํ ๋ด์ฉ์ ํ์ธํ ์ ์์ต๋๋ค.
@@ -1463,25 +1462,26 @@ Google ์ธ์ฆ๊ธฐ๋ 2๋จ๊ณ ์ธ์ฆ ์๋น์ค๋ฅผ ๊ตฌํํ๋ ์ํํธ์จ์ด ๊ธฐ
๋ ์คํ
์ด์ง๊ฐ ์์ต๋๋ค.
-- ์คํ
์ด์ง 1 - ์ฌ์ฉ์๊ฐ Google 2๋จ๊ณ ์ธ์ฆ์ ํ์ฑํํฉ๋๋ค.
+- ์คํ
์ด์ง 1 - ์ฌ์ฉ์๊ฐ ๊ตฌ๊ธ 2๋จ๊ณ ์ธ์ฆ์ ํ์ฑํํฉ๋๋ค.
- ์คํ
์ด์ง 2 - ์ฌ์ฉ์๋ ๋ก๊ทธ์ธ ๋ฑ์ ์ธ์ฆ๊ธฐ๋ฅผ ์ฌ์ฉํฉ๋๋ค.
์ด ์คํ
์ด์ง๋ฅผ ์ดํด๋ณด๊ฒ ์ต๋๋ค.
-**์คํ
์ด์ง1**
+**์คํ
์ด์ง1**
-๋จ๊ณ 1,2: Bob์ด ์น ํ์ด์ง๋ฅผ ์ด์ด 2๋จ๊ณ ์ธ์ฆ์ ํ์ฑํํฉ๋๋ค. ํ๋ก ํธ์๋์์ ์ํฌ๋ฆฟ ํค๋ฅผ ์์ฒญํฉ๋๋ค. ์ธ์ฆ ์๋น์ค์์ Bob์ ์ํฌ๋ฆฟ ํค๋ฅผ ์์ฑํ์ฌ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ์ ์ฅํฉ๋๋ค.
+1,2 ๋จ๊ณ: Bob์ด ์น ํ์ด์ง๋ฅผ ์ด์ด 2๋จ๊ณ ์ธ์ฆ์ ํ์ฑํํฉ๋๋ค. ํ๋ก ํธ์๋์์ ์ํฌ๋ฆฟ ํค๋ฅผ ์์ฒญํฉ๋๋ค. ์ธ์ฆ ์๋น์ค์์ Bob์ ์ํฌ๋ฆฟ ํค๋ฅผ ์์ฑํ์ฌ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ์ ์ฅํฉ๋๋ค.
-๋จ๊ณ 3: ์ธ์ฆ ์๋น์ค๋ ํ๋ก ํธ์๋์ URI๋ฅผ ๋ฐํํฉ๋๋ค. URI๋ ํค ๋ฐ๊ธ์, ์ฌ์ฉ์ ์ด๋ฆ, ์ํฌ๋ฆฟ ํค๋ก ๊ตฌ์ฑ๋ฉ๋๋ค. URI๋ ์น ํ์ด์ง์ QR ์ฝ๋ ํํ๋ก ํ์๋ฉ๋๋ค.
+3 ๋จ๊ณ: ์ธ์ฆ ์๋น์ค๋ ํ๋ก ํธ์๋์ URI๋ฅผ ๋ฐํํฉ๋๋ค. URI๋ ํค ๋ฐ๊ธ์, ์ฌ์ฉ์ ์ด๋ฆ, ์ํฌ๋ฆฟ ํค๋ก ๊ตฌ์ฑ๋ฉ๋๋ค. URI๋ ์น ํ์ด์ง์ QR ์ฝ๋ ํํ๋ก ํ์๋ฉ๋๋ค.
-๋จ๊ณ 4: ๊ทธ๋ฐ ๋ค์ Bob์ Google ์ธ์ฆ๊ธฐ๋ฅผ ์ฌ์ฉํ์ฌ ์์ฑ๋ QR ์ฝ๋๋ฅผ ์ค์บํฉ๋๋ค. ์ํฌ๋ฆฟ ํค๋ ์ธ์ฆ๊ธฐ์ ์ ์ฅ๋ฉ๋๋ค.
+4 ๋จ๊ณ: ๊ทธ๋ฐ ๋ค์ Bob์ ๊ตฌ๊ธ ์ธ์ฆ๊ธฐ๋ฅผ ์ฌ์ฉํ์ฌ ์์ฑ๋ QR ์ฝ๋๋ฅผ ์ค์บํฉ๋๋ค. ์ํฌ๋ฆฟ ํค๋ ์ธ์ฆ๊ธฐ์ ์ ์ฅ๋ฉ๋๋ค.
**์คํ
์ด์ง2**
-๋จ๊ณ 1, 2: ๋ฐฅ์ ๊ตฌ๊ธ 2๋จ๊ณ ์ธ์ฆ์ผ๋ก ์น์ฌ์ดํธ์ ๋ก๊ทธ์ธํ๋ ค๊ณ ํฉ๋๋ค. ์ด๋ฅผ ์ํด์๋ ๋น๋ฐ๋ฒํธ๊ฐ ํ์ํฉ๋๋ค. Google ์ธ์ฆ๊ธฐ๋ 30์ด๋ง๋ค TOTP(Time-based One Time Password) ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํ์ฌ 6์๋ฆฌ ๋น๋ฐ๋ฒํธ๋ฅผ ์์ฑํฉ๋๋ค. ๋ฐฅ์ ์ด ๋น๋ฐ๋ฒํธ๋ฅผ ์ฌ์ฉํ์ฌ ์น์ฌ์ดํธ์ ๋ค์ด๊ฐ๋๋ค.
+
+1, 2 ๋จ๊ณ: ๋ฐฅ์ ๊ตฌ๊ธ 2๋จ๊ณ ์ธ์ฆ์ผ๋ก ์น์ฌ์ดํธ์ ๋ก๊ทธ์ธํ๋ ค๊ณ ํฉ๋๋ค. ์ด๋ฅผ ์ํด์๋ ๋น๋ฐ๋ฒํธ๊ฐ ํ์ํฉ๋๋ค. ๊ตฌ๊ธ ์ธ์ฆ๊ธฐ๋ 30์ด๋ง๋ค TOTP(Time-based One Time Password) ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํ์ฌ 6์๋ฆฌ ๋น๋ฐ๋ฒํธ๋ฅผ ์์ฑํฉ๋๋ค. ๋ฐฅ์ ์ด ๋น๋ฐ๋ฒํธ๋ฅผ ์ฌ์ฉํ์ฌ ์น์ฌ์ดํธ์ ๋ค์ด๊ฐ๋๋ค.
-๋จ๊ณ 3, 4: ํ๋ก ํธ์๋๋ ์ธ์ฆ์ ์ํด ๋ฐฅ์ด ์
๋ ฅํ ๋น๋ฐ๋ฒํธ๋ฅผ ๋ฐฑ์๋๋ก ์ ์กํฉ๋๋ค. ์ธ์ฆ ์๋น์ค๋ ๋ฐ์ดํฐ๋ฒ ์ด์ค์์ ์ํฌ๋ฆฟ ํค๋ฅผ ์ฝ๊ณ ํด๋ผ์ด์ธํธ์ ๋์ผํ TOTP ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํ์ฌ 6์๋ฆฌ ๋น๋ฐ๋ฒํธ๋ฅผ ์์ฑํฉ๋๋ค.
+3, 4 ๋จ๊ณ: ํ๋ก ํธ์๋๋ ์ธ์ฆ์ ์ํด ๋ฐฅ์ด ์
๋ ฅํ ๋น๋ฐ๋ฒํธ๋ฅผ ๋ฐฑ์๋๋ก ์ ์กํฉ๋๋ค. ์ธ์ฆ ์๋น์ค๋ ๋ฐ์ดํฐ๋ฒ ์ด์ค์์ ์ํฌ๋ฆฟ ํค๋ฅผ ์ฝ๊ณ ํด๋ผ์ด์ธํธ์ ๋์ผํ TOTP ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํ์ฌ 6์๋ฆฌ ๋น๋ฐ๋ฒํธ๋ฅผ ์์ฑํฉ๋๋ค.
-๋จ๊ณ 5: ์ธ์ฆ ์๋น์ค๋ ํด๋ผ์ด์ธํธ์ ์๋ฒ์์ ์์ฑํ ๋ ๊ฐ์ ๋น๋ฐ๋ฒํธ๋ฅผ ๋น๊ตํ๊ณ ๋น๊ต ๊ฒฐ๊ณผ๋ฅผ ํ๋ก ํธ์๋์ ๋ฐํํฉ๋๋ค. Bob์ ๋ ๋น๋ฐ๋ฒํธ๊ฐ ์ผ์นํ๋ ๊ฒฝ์ฐ์๋ง ๋ก๊ทธ์ธ ํ๋ก์ธ์ค๋ฅผ ์งํํ ์ ์์ต๋๋ค.
+5 ๋จ๊ณ: ์ธ์ฆ ์๋น์ค๋ ํด๋ผ์ด์ธํธ์ ์๋ฒ์์ ์์ฑํ ๋ ๊ฐ์ ๋น๋ฐ๋ฒํธ๋ฅผ ๋น๊ตํ๊ณ ๋น๊ต ๊ฒฐ๊ณผ๋ฅผ ํ๋ก ํธ์๋์ ๋ฐํํฉ๋๋ค. Bob์ ๋ ๋น๋ฐ๋ฒํธ๊ฐ ์ผ์นํ๋ ๊ฒฝ์ฐ์๋ง ๋ก๊ทธ์ธ ํ๋ก์ธ์ค๋ฅผ ์งํํ ์ ์์ต๋๋ค.
์ด ์ธ์ฆ ๋ฉ์ปค๋์ฆ์ ์์ ํ๊ฐ์?
@@ -1542,7 +1542,7 @@ Google ์ธ์ฆ๊ธฐ๋ 2๋จ๊ณ ์ธ์ฆ ์๋น์ค๋ฅผ ๊ตฌํํ๋ ์ํํธ์จ์ด ๊ธฐ
์์ด๋น์ค๋น๋ ํธ์คํธ์ ๊ฒ์คํธ๋ฅผ ์ํ ๋จ์ํ ๋ง์ผํ๋ ์ด์ค์์ ์์๋์์ต๋๋ค. ์ด๋ ๋ชจ๋๋ฆฌ์ค๋ผ๊ณ ํ๋ Ruby on Rails ์ ํ๋ฆฌ์ผ์ด์
์ผ๋ก ๊ตฌ์ถ๋์์ต๋๋ค.
-๋์ ๊ณผ์ ๋ ๋ฌด์์ธ๊ฐ์?
+์ฑ๋ฆฐ์ง๋ ๋ฌด์์ธ๊ฐ์?
- ํผ๋์ค๋ฌ์ด ํ ์ค๋์ญ + ์ค๋์ญ ์๋ ์ฝ๋
- ๋๋ฆฐ ๊ฐ๋ฐ
@@ -1555,9 +1555,9 @@ Google ์ธ์ฆ๊ธฐ๋ 2๋จ๊ณ ์ธ์ฆ ์๋น์ค๋ฅผ ๊ตฌํํ๋ ์ํํธ์จ์ด ๊ธฐ
- Business logic data service
- Write workflow service
- UI aggregation service
-- Each service had one owning team
+- ๊ฐ ์๋น์ค์๋ ํ๋์ ์ ๋ด ํ ๋๊ธฐ
-๋์ ๊ณผ์ ๋ ๋ฌด์์ธ๊ฐ์?
+์ฑ๋ฆฐ์ง๋ ๋ฌด์์ธ๊ฐ์?
์๋ฐฑ ๊ฐ์ ์๋น์ค์ ์ข
์์ฑ์ ์ฌ๋์ด ๊ด๋ฆฌํ๊ธฐ ์ด๋ ค์ ์ต๋๋ค.
@@ -1574,24 +1574,24 @@ Google ์ธ์ฆ๊ธฐ๋ 2๋จ๊ณ ์ธ์ฆ ์๋น์ค๋ฅผ ๊ตฌํํ๋ ์ํํธ์จ์ด ๊ธฐ
-๋ชจ๋
ธ๋ ํฌ๋ ์๋ก์ด ๊ฒ์ด ์๋๋๋ค. Linux์ Windows ๋ชจ๋ ๋ชจ๋
ธ๋ ํฌ๋ฅผ ์ฌ์ฉํ์ฌ ๋ง๋ค์ด์ก์ต๋๋ค. ํ์ฅ์ฑ๊ณผ ๋น๋ ์๋๋ฅผ ๊ฐ์ ํ๊ธฐ ์ํด Google์ ๋ด๋ถ ์ ์ฉ ํด์ฒด์ธ์ ๊ฐ๋ฐํ์ฌ ๋ ๋น ๋ฅด๊ฒ ํ์ฅํ๊ณ ์๊ฒฉํ ์ฝ๋ฉ ํ์ง ํ์ค์ ์ ์ฉํ์ฌ ์ผ๊ด์ฑ์ ์ ์งํ์ต๋๋ค.
+๋ชจ๋
ธ๋ ํฌ๋ ์๋ก์ด ๊ฒ์ด ์๋๋๋ค. Linux์ Windows ๋ชจ๋ ๋ชจ๋
ธ๋ ํฌ๋ฅผ ์ฌ์ฉํ์ฌ ๋ง๋ค์ด์ก์ต๋๋ค. ํ์ฅ์ฑ๊ณผ ๋น๋ ์๋๋ฅผ ๊ฐ์ ํ๊ธฐ ์ํด ๊ตฌ๊ธ์ ๋ด๋ถ ์ ์ฉ ํด์ฒด์ธ์ ๊ฐ๋ฐํ์ฌ ๋ ๋น ๋ฅด๊ฒ ํ์ฅํ๊ณ ์๊ฒฉํ ์ฝ๋ฉ ํ์ง ํ์ค์ ์ ์ฉํ์ฌ ์ผ๊ด์ฑ์ ์ ์งํ์ต๋๋ค.
์๋ง์กด๊ณผ ๋ทํ๋ฆญ์ค๋ ๋ง์ดํฌ๋ก์๋น์ค ์ฒ ํ์ ์ฃผ์ ํ๋ณด๋์ฌ์
๋๋ค. ์ด ์ ๊ทผ ๋ฐฉ์์ ์์ฐ์ค๋ฝ๊ฒ ์๋น์ค ์ฝ๋๋ฅผ ๋ณ๋์ ๋ฆฌํฌ์งํ ๋ฆฌ๋ก ๋ถ๋ฆฌํฉ๋๋ค. ํ์ฅ ์๋๋ ๋น ๋ฅด์ง๋ง ๋์ค์ ๊ฑฐ๋ฒ๋์ค ๋ฌธ์ ๊ฐ ๋ฐ์ํ ์ ์์ต๋๋ค.
๋ชจ๋
ธ๋ ํฌ ๋ด์์ ๊ฐ ์๋น์ค๋ ํ๋์ ํด๋์ด๋ฉฐ, ๋ชจ๋ ํด๋์๋ ๋น๋ ๊ตฌ์ฑ ๋ฐ ์์ ์ ๊ถํ ์ ์ด๊ฐ ์์ต๋๋ค. ๋ชจ๋ ์๋น์ค ๊ตฌ์ฑ์์ ์์ ์ ํด๋์ ๋ํ ์ฑ
์์ด ์์ต๋๋ค.
-๋ฐ๋ฉด Microrepo์์๋ ๊ฐ ์๋น์ค๊ฐ ํด๋น ๋ฆฌํฌ์งํ ๋ฆฌ๋ฅผ ๋ด๋นํ๋ฉฐ, ์ผ๋ฐ์ ์ผ๋ก ์ ์ฒด ๋ฆฌํฌ์งํ ๋ฆฌ์ ๋ํ ๋น๋ ๊ตฌ์ฑ๊ณผ ๊ถํ์ด ์ค์ ๋ฉ๋๋ค.
+๋ฐ๋ฉด ๋ง์ดํฌ๋ก๋ ํฌ์์๋ ๊ฐ ์๋น์ค๊ฐ ํด๋น ๋ฆฌํฌ์งํ ๋ฆฌ๋ฅผ ๋ด๋นํ๋ฉฐ, ์ผ๋ฐ์ ์ผ๋ก ์ ์ฒด ๋ฆฌํฌ์งํ ๋ฆฌ์ ๋ํ ๋น๋ ๊ตฌ์ฑ๊ณผ ๊ถํ์ด ์ค์ ๋ฉ๋๋ค.
-Monorepo์์๋ ๋น์ฆ๋์ค์ ๊ด๊ณ์์ด ์ ์ฒด ์ฝ๋๋ฒ ์ด์ค์์ ์ข
์์ฑ์ด ๊ณต์ ๋๋ฏ๋ก ๋ฒ์ ์
๊ทธ๋ ์ด๋๊ฐ ์์ ๋ ๋ชจ๋ ์ฝ๋๋ฒ ์ด์ค๊ฐ ํด๋น ๋ฒ์ ์ ์
๊ทธ๋ ์ด๋ํฉ๋๋ค.
+๋ชจ๋
ธ๋ ํฌ์์๋ ๋น์ฆ๋์ค์ ๊ด๊ณ์์ด ์ ์ฒด ์ฝ๋๋ฒ ์ด์ค์์ ์ข
์์ฑ์ด ๊ณต์ ๋๋ฏ๋ก ๋ฒ์ ์
๊ทธ๋ ์ด๋๊ฐ ์์ ๋ ๋ชจ๋ ์ฝ๋๋ฒ ์ด์ค๊ฐ ํด๋น ๋ฒ์ ์ ์
๊ทธ๋ ์ด๋ํฉ๋๋ค.
-Microrepo์์๋ ๊ฐ ๋ฆฌํฌ์งํ ๋ฆฌ ๋ด์์ ์ข
์์ฑ์ ์ ์ดํฉ๋๋ค. ๊ธฐ์
์ ์์ฒด ์ผ์ ์ ๋ฐ๋ผ ๋ฒ์ ์ ์
๊ทธ๋ ์ด๋ํ ์๊ธฐ๋ฅผ ์ ํํ ์ ์์ต๋๋ค.
+๋ง์ดํฌ๋ก๋ ํฌ์์๋ ๊ฐ ๋ฆฌํฌ์งํ ๋ฆฌ ๋ด์์ ์ข
์์ฑ์ ์ ์ดํฉ๋๋ค. ๊ธฐ์
์ ์์ฒด ์ผ์ ์ ๋ฐ๋ผ ๋ฒ์ ์ ์
๊ทธ๋ ์ด๋ํ ์๊ธฐ๋ฅผ ์ ํํ ์ ์์ต๋๋ค.
-๋ชจ๋
ธ๋ ํฌ์๋ ์ฒดํฌ์ธ์ ๋ํ ํ์ค์ด ์์ต๋๋ค. Google์ ์ฝ๋ ๊ฒํ ํ๋ก์ธ์ค๋ ๋์ ๊ธฐ์ค์ ์ค์ ํ๋ ๊ฒ์ผ๋ก ์ ๋ช
ํ๋ฉฐ, ๋น์ฆ๋์ค์ ๊ด๊ณ์์ด Monorepo์ ์ผ๊ด๋ ํ์ง ํ์ค์ ๋ณด์ฅํฉ๋๋ค.
+๋ชจ๋
ธ๋ ํฌ์๋ ์ฒดํฌ์ธ์ ๋ํ ํ์ค์ด ์์ต๋๋ค. ๊ตฌ๊ธ์ ์ฝ๋ ๊ฒํ ํ๋ก์ธ์ค๋ ๋์ ๊ธฐ์ค์ ์ค์ ํ๋ ๊ฒ์ผ๋ก ์ ๋ช
ํ๋ฉฐ, ๋น์ฆ๋์ค์ ๊ด๊ณ์์ด ๋ชจ๋
ธ๋ ํฌ์ ์ผ๊ด๋ ํ์ง ํ์ค์ ๋ณด์ฅํฉ๋๋ค.
-Microrepo๋ ์์ฒด ํ์ค์ ์ค์ ํ๊ฑฐ๋ ๋ชจ๋ฒ ์ฌ๋ก๋ฅผ ํตํฉํ์ฌ ๊ณต์ ํ์ค์ ์ฑํํ ์ ์์ต๋๋ค. ๋น์ฆ๋์ค์ ๋ง๊ฒ ๋ ๋น ๋ฅด๊ฒ ํ์ฅํ ์ ์์ง๋ง ์ฝ๋ ํ์ง์ด ์ฝ๊ฐ ๋ค๋ฅผ ์ ์์ต๋๋ค.
-Google ์์ง๋์ด๋ Bazel์, Meta๋ Buck์ ๋ง๋ค์์ต๋๋ค. ๊ทธ ์ธ์๋ Nx, Lerna ๋ฑ ๋ค์ํ ์คํ ์์ค ๋๊ตฌ๊ฐ ์์ต๋๋ค.
+๋ง์ดํฌ๋ก๋ ํฌ๋ ์์ฒด ํ์ค์ ์ค์ ํ๊ฑฐ๋ ๋ชจ๋ฒ ์ฌ๋ก๋ฅผ ํตํฉํ์ฌ ๊ณต์ ํ์ค์ ์ฑํํ ์ ์์ต๋๋ค. ๋น์ฆ๋์ค์ ๋ง๊ฒ ๋ ๋น ๋ฅด๊ฒ ํ์ฅํ ์ ์์ง๋ง ์ฝ๋ ํ์ง์ด ์ฝ๊ฐ ๋ค๋ฅผ ์ ์์ต๋๋ค.
+๊ตฌ๊ธ ์์ง๋์ด๋ Bazel์, Meta๋ Buck์ ๋ง๋ค์์ต๋๋ค. ๊ทธ ์ธ์๋ Nx, Lerna ๋ฑ ๋ค์ํ ์คํ ์์ค ๋๊ตฌ๊ฐ ์์ต๋๋ค.
-์๋
์ ๊ฑธ์ณ Microrepo๋ Java์ฉ Maven๊ณผ Gradle, NodeJS์ฉ NPM, C/C++์ฉ CMake ๋ฑ ๋ ๋ง์ ๋๊ตฌ๋ฅผ ์ง์ํ๊ฒ ๋์์ต๋๋ค.
+์๋
์ ๊ฑธ์ณ ๋ง์ดํฌ๋ก๋ ํฌ๋ Java์ฉ Maven๊ณผ Gradle, NodeJS์ฉ NPM, C/C++์ฉ CMake ๋ฑ ๋ ๋ง์ ๋๊ตฌ๋ฅผ ์ง์ํ๊ฒ ๋์์ต๋๋ค.
### ์คํ ์ค๋ฒํ๋ก ์น์ฌ์ดํธ๋ฅผ ์ด๋ป๊ฒ ๋์์ธํ ๊ฑด๊ฐ์?
@@ -1628,7 +1628,7 @@ Google ์์ง๋์ด๋ Bazel์, Meta๋ Buck์ ๋ง๋ค์์ต๋๋ค. ๊ทธ ์ธ์
-Amazon ํ๋ผ์ ๋น๋์ค ๋ชจ๋ํฐ๋ง ์๋น์ค๋ ๋ฌด์์ธ๊ฐ์?
+์๋ง์กด ํ๋ผ์ ๋น๋์ค ๋ชจ๋ํฐ๋ง ์๋น์ค๋ ๋ฌด์์ธ๊ฐ์?
ํ๋ผ์ ๋น๋์ค ์๋น์ค๋ ์์ฒ ๊ฐ์ ๋ผ์ด๋ธ ์คํธ๋ฆผ์ ํ์ง์ ๋ชจ๋ํฐ๋งํด์ผ ํฉ๋๋ค. ๋ชจ๋ํฐ๋ง ๋๊ตฌ๋ ์ค์๊ฐ์ผ๋ก ์คํธ๋ฆผ์ ์๋์ผ๋ก ๋ถ์ํ๊ณ ๋ธ๋ก ์์, ๋์์ ์ ์ง, ๋๊ธฐํ ๋ฌธ์ ์ ๊ฐ์ ํ์ง ๋ฌธ์ ๋ฅผ ์๋ณํฉ๋๋ค. ์ด๋ ๊ณ ๊ฐ ๋ง์กฑ์ ์ํ ์ค์ํ ํ๋ก์ธ์ค์
๋๋ค.
@@ -1636,11 +1636,11 @@ Amazon ํ๋ผ์ ๋น๋์ค ๋ชจ๋ํฐ๋ง ์๋น์ค๋ ๋ฌด์์ธ๊ฐ์?
- ๊ธฐ์กด ์ํคํ
์ฒ์ ๋ฌธ์ ์ ์ ๋ฌด์์ธ๊ฐ์?
- ์ด์ ์ํคํ
์ฒ๋ Amazon Lambda๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํ์ฌ ์๋น์ค๋ฅผ ๋น ๋ฅด๊ฒ ๊ตฌ์ถํ๋ ๋ฐ๋ ์ข์์ต๋๋ค. ํ์ง๋ง ๋๊ท๋ชจ๋ก ์ํคํ
์ฒ๋ฅผ ์คํํ ๋๋ ๋น์ฉ ํจ์จ์ ์ด์ง ์์์ต๋๋ค. ๋ค์์ ๊ฐ์ฅ ๋น์ฉ์ด ๋ง์ด ๋๋ ๋ ๊ฐ์ง ์์
์
๋๋ค.
+ ์ด์ ์ํคํ
์ฒ๋ ์๋ง์กด ๋๋ค๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํ์ฌ ์๋น์ค๋ฅผ ๋น ๋ฅด๊ฒ ๊ตฌ์ถํ๋ ๋ฐ๋ ์ข์์ต๋๋ค. ํ์ง๋ง ๋๊ท๋ชจ๋ก ์ํคํ
์ฒ๋ฅผ ์คํํ ๋๋ ๋น์ฉ ํจ์จ์ ์ด์ง ์์์ต๋๋ค. ๋ค์์ ๊ฐ์ฅ ๋น์ฉ์ด ๋ง์ด ๋๋ ๋ ๊ฐ์ง ์์
์
๋๋ค.
1. ์ค์ผ์คํธ๋ ์ด์
์ํฌํ๋ก - AWS ์คํ
ํจ์๋ ์ํ ์ ํ๋ณ๋ก ์ฌ์ฉ์์๊ฒ ์๊ธ์ ๋ถ๊ณผํ๊ณ , ์ค์ผ์คํธ๋ ์ด์
์ ๋งค์ด๋ง๋ค ์ฌ๋ฌ ์ํ ์ ํ์ ์ํํฉ๋๋ค.
-2. ๋ถ์ฐ๋ ์ปดํฌ๋ํธ ๊ฐ์ ๋ฐ์ดํฐ ์ ๋ฌ - ์ธํฐ๋ฏธ๋์ดํธ ๋ฐ์ดํฐ๋ ๋ค์ ์คํ
์ด์ง์ ๋ค์ด๋ก๋๋ฅผ ์ํด Amazon S3์ ์ ์ฅ๋ฉ๋๋ค. ๋ณผ๋ฅจ์ด ํฌ๋ฉด ๋ค์ด๋ก๋ ๋น์ฉ์ด ๋ง์ด ๋ค ์ ์์ต๋๋ค.
+2. ๋ถ์ฐ๋ ์ปดํฌ๋ํธ ๊ฐ์ ๋ฐ์ดํฐ ์ ๋ฌ - ์ธํฐ๋ฏธ๋์ดํธ ๋ฐ์ดํฐ๋ ๋ค์ ์คํ
์ด์ง์ ๋ค์ด๋ก๋๋ฅผ ์ํด ์๋ง์กด S3์ ์ ์ฅ๋ฉ๋๋ค. ๋ณผ๋ฅจ์ด ํฌ๋ฉด ๋ค์ด๋ก๋ ๋น์ฉ์ด ๋ง์ด ๋ค ์ ์์ต๋๋ค.
- ๋ชจ๋๋ฆฌ์ ์ํคํ
์ฒ๋ก 90% ๋น์ฉ ์ ๊ฐ
@@ -1663,9 +1663,9 @@ Ex Amazon VP Sustainability Adrian Cockcroft: "ํ๋ผ์ ๋น๋์ค ํ์ ์ ๊ฐ
1. ํด๋ผ์ด์ธํธ๋ ํ์ค HTTP ์์ฒญ์ ํตํด ์ด๋ชจํฐ์ฝ์ ์ ์กํฉ๋๋ค. ๊ณ ๋ญ ์๋น์ค๋ ์ผ๋ฐ์ ์ธ ์น ์๋ฒ๋ผ๊ณ ์๊ฐํ๋ฉด ๋ฉ๋๋ค. ๊ณ ๋ญ์ ์ ํํ ์ด์ ๋ ๋์์ฑ์ ์ ์ง์ํ๊ธฐ ๋๋ฌธ์
๋๋ค. ๊ณ ๋ญ์ ์ค๋ ๋๋ ๊ฐ๋ณ์ต๋๋ค.
-2. ์ฐ๊ธฐ ๋ณผ๋ฅจ์ด ๋งค์ฐ ๋๊ธฐ ๋๋ฌธ์ Kafka(๋ฉ์์ง ํ)๊ฐ ๋ฒํผ๋ก ์ฌ์ฉ๋ฉ๋๋ค.
+2. ์ฐ๊ธฐ ๋ณผ๋ฅจ์ด ๋งค์ฐ ๋๊ธฐ ๋๋ฌธ์ ์นดํ์นด(๋ฉ์์ง ํ)๊ฐ ๋ฒํผ๋ก ์ฌ์ฉ๋ฉ๋๋ค.
-3. ์ด๋ชจํฐ์ฝ ๋ฐ์ดํฐ๋ Spark๋ผ๋ ์คํธ๋ฆฌ๋ฐ ์ฒ๋ฆฌ ์๋น์ค์ ์ํด ์ด๊ทธ๋ฆฌ๊ฒ์ดํธ๋ฉ๋๋ค. ์ด ์๋น์ค๋ 2์ด๋ง๋ค ๋ฐ์ดํฐ๋ฅผ ์ด๊ทธ๋ฆฌ๊ฒ์ดํธํ๋ฉฐ, ๊ทธ ์ฃผ๊ธฐ๋ ์ค์ ํ ์ ์์ต๋๋ค. ๊ฐ๊ฒฉ์ ๋ฐ๋ผ ํธ๋ ์ด๋์คํ๊ฐ ์์ต๋๋ค. ๊ฐ๊ฒฉ์ด ์งง์์๋ก ๋ค๋ฅธ ํด๋ผ์ด์ธํธ์ ์ด๋ชจํฐ์ฝ์ด ๋ ๋นจ๋ฆฌ ์ ๋ฌ๋์ง๋ง ๋ ๋ง์ ์ปดํจํ
๋ฆฌ์์ค๊ฐ ํ์ํ๋ค๋ ์๋ฏธ๋ ๋ฉ๋๋ค.
+3. ์ด๋ชจํฐ์ฝ ๋ฐ์ดํฐ๋ Spark๋ผ๋ ์คํธ๋ฆฌ๋ฐ ์ฒ๋ฆฌ ์๋น์ค์ ์ํด ์ด๊ทธ๋ฆฌ๊ฒ์ดํธ๋ฉ๋๋ค. ์ด ์๋น์ค๋ 2์ด๋ง๋ค ๋ฐ์ดํฐ๋ฅผ ์ด๊ทธ๋ฆฌ๊ฒ์ดํธํ๋ฉฐ, ๊ทธ ์ฃผ๊ธฐ๋ ์ค์ ํ ์ ์์ต๋๋ค. ๊ฐ๊ฒฉ์ ๋ฐ๋ผ ์ฅ๋จ์ ์ด ์์ต๋๋ค. ๊ฐ๊ฒฉ์ด ์งง์์๋ก ๋ค๋ฅธ ํด๋ผ์ด์ธํธ์ ์ด๋ชจํฐ์ฝ์ด ๋ ๋นจ๋ฆฌ ์ ๋ฌ๋์ง๋ง ๋ ๋ง์ ์ปดํจํ
๋ฆฌ์์ค๊ฐ ํ์ํ๋ค๋ ์๋ฏธ๋ ๋ฉ๋๋ค.
4. ์ด๊ทธ๋ฆฌ๊ฒ์ดํธ๋ ๋ฐ์ดํฐ๋ ๋ ๋ค๋ฅธ ์นดํ์นด์ ๊ธฐ๋ก๋ฉ๋๋ค.
@@ -1684,23 +1684,23 @@ Ex Amazon VP Sustainability Adrian Cockcroft: "ํ๋ผ์ ๋น๋์ค ํ์ ์ ๊ฐ
-๋ชฝ๊ณ DB โก๏ธ ์นด์ฐ๋๋ผ โก๏ธ ์ค๋ผDB
+MongoDB โก๏ธ Cassandra โก๏ธ ScyllaDB
-2015๋
, Discord์ ์ฒซ ๋ฒ์งธ ๋ฒ์ ์ ๋จ์ผ MongoDB ๋ ํ๋ฆฌ์นด ์์ ๊ตฌ์ถ๋์์ต๋๋ค. 2015๋
11์๊ฒฝ, MongoDB์ 1์ต ๊ฐ์ ๋ฉ์์ง๊ฐ ์ ์ฅ๋์ RAM์ด ๋ ์ด์ ๋ฐ์ดํฐ์ ์์ธ์ ์ ์ฅํ ์ ์๊ฒ ๋์์ต๋๋ค. ์ง์ฐ ์๊ฐ์ ์์ธกํ ์ ์๊ฒ ๋์์ต๋๋ค. ๋ฉ์์ง ์ ์ฅ์๋ฅผ ๋ค๋ฅธ ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ก ์ฎ๊ฒจ์ผ ํ์ต๋๋ค. ์นด์ฐ๋๋ผ๊ฐ ์ ํ๋์์ต๋๋ค.
+2015๋
, ๋์ค์ฝ๋์ ์ฒซ ๋ฒ์งธ ๋ฒ์ ์ ๋จ์ผ MongoDB ๋ ํ๋ฆฌ์นด ์์ ๊ตฌ์ถ๋์์ต๋๋ค. 2015๋
11์๊ฒฝ, MongoDB์ 1์ต ๊ฐ์ ๋ฉ์์ง๊ฐ ์ ์ฅ๋์ RAM์ด ๋ ์ด์ ๋ฐ์ดํฐ์ ์์ธ์ ์ ์ฅํ ์ ์๊ฒ ๋์์ต๋๋ค. ์ง์ฐ ์๊ฐ์ ์์ธกํ ์ ์๊ฒ ๋์์ต๋๋ค. ๋ฉ์์ง ์ ์ฅ์๋ฅผ ๋ค๋ฅธ ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ก ์ฎ๊ฒจ์ผ ํ๊ณ , ์นด์ฐ๋๋ผ๊ฐ ์ ํ๋์์ต๋๋ค.
-2017๋
, Discord์๋ 12๊ฐ์ ์นด์ฐ๋๋ผ ๋
ธ๋๊ฐ ์์๊ณ ์์ญ์ต ๊ฐ์ ๋ฉ์์ง๊ฐ ์ ์ฅ๋์ด ์์์ต๋๋ค.
+2017๋
, ๋์ค์ฝ๋์๋ 12๊ฐ์ ์นด์ฐ๋๋ผ ๋
ธ๋๊ฐ ์์๊ณ ์์ญ์ต ๊ฐ์ ๋ฉ์์ง๊ฐ ์ ์ฅ๋์ด ์์์ต๋๋ค.
2022๋
์ด์๋ 177๊ฐ์ ๋
ธ๋์ ์์กฐ ๊ฐ์ ๋ฉ์์ง๊ฐ ์์์ต๋๋ค. ์ด ์์ ์์๋ ์ง์ฐ ์๊ฐ์ ์์ธกํ ์ ์์๊ณ ์ ์ง๋ณด์ ์ด์ ๋น์ฉ์ด ๋๋ฌด ๋ง์ด ๋ค์์ต๋๋ค.
์ฌ๊ธฐ์๋ ๋ช ๊ฐ์ง ์ด์ ๊ฐ ์์ต๋๋ค.
-- Cassandra๋ ๋ด๋ถ ๋ฐ์ดํฐ ๊ตฌ์กฐ์ LSM ํธ๋ฆฌ๋ฅผ ์ฌ์ฉํฉ๋๋ค. ์ฝ๊ธฐ๋ ์ฐ๊ธฐ๋ณด๋ค ๋น์ฉ์ด ๋ ๋ง์ด ๋ญ๋๋ค. ์๋ฐฑ ๋ช
์ ์ฌ์ฉ์๊ฐ ์๋ ์๋ฒ์์ ๋์ ์ฝ๊ธฐ๊ฐ ๋ง์ด ๋ฐ์ํ์ฌ ํซ์คํ์ด ๋ฐ์ํ ์ ์์ต๋๋ค.
+- ์นด์ฐ๋๋ผ๋ ๋ด๋ถ ๋ฐ์ดํฐ ๊ตฌ์กฐ์ LSM ํธ๋ฆฌ๋ฅผ ์ฌ์ฉํฉ๋๋ค. ์ฝ๊ธฐ๋ ์ฐ๊ธฐ๋ณด๋ค ๋น์ฉ์ด ๋ ๋ง์ด ๋ญ๋๋ค. ์๋ฐฑ ๋ช
์ ์ฌ์ฉ์๊ฐ ์๋ ์๋ฒ์์ ๋์ ์ฝ๊ธฐ๊ฐ ๋ง์ด ๋ฐ์ํ์ฌ ํซ์คํ์ด ๋ฐ์ํ ์ ์์ต๋๋ค.
- SSTable์ ์์ถํ๋ ๋ฑ ํด๋ฌ์คํฐ๋ฅผ ์ ์ง ๊ด๋ฆฌํ๋ฉด ์ฑ๋ฅ์ ์ํฅ์ ๋ฏธ์นฉ๋๋ค.
- ๊ฐ๋น์ง ์ปฌ๋ ์
์ผ์ ์ค์ง๋ก ์ธํด ์ง์ฐ ์๊ฐ์ด ํฌ๊ฒ ์ฆ๊ฐํฉ๋๋ค.
-ScyllaDB๋ C++๋ก ์์ฑ๋ ์นด์ฐ๋๋ผ ํธํ ๋ฐ์ดํฐ๋ฒ ์ด์ค์
๋๋ค. Discord๋ ๋ชจ๋๋ฆฌ์ API, Rust๋ก ์์ฑ๋ ๋ฐ์ดํฐ ์๋น์ค, ScyllaDB ๊ธฐ๋ฐ ์คํ ๋ฆฌ์ง๋ฅผ ๊ฐ์ถ๋๋ก ์ํคํ
์ฒ๋ฅผ ์ฌ์ค๊ณํ์ต๋๋ค.
+ScyllaDB๋ C++๋ก ์์ฑ๋ ์นด์ฐ๋๋ผ ํธํ ๋ฐ์ดํฐ๋ฒ ์ด์ค์
๋๋ค. ๋์ค์ฝ๋๋ ๋ชจ๋๋ฆฌ์ API, Rust๋ก ์์ฑ๋ ๋ฐ์ดํฐ ์๋น์ค, ScyllaDB ๊ธฐ๋ฐ ์คํ ๋ฆฌ์ง๋ฅผ ๊ฐ์ถ๋๋ก ์ํคํ
์ฒ๋ฅผ ์ฌ์ค๊ณํ์ต๋๋ค.
-ScyllaDB์ p99 ์ฝ๊ธฐ ์ง์ฐ ์๊ฐ์ 15ms์ธ ๋ฐ๋ฉด Cassandra๋ 40-125ms์
๋๋ค. p99 ์ฐ๊ธฐ ์ง์ฐ ์๊ฐ์ 5ms์ธ๋ฐ ๋ฐํด Cassandra๋ 5-70ms์
๋๋ค.
+ScyllaDB์ p99 ์ฝ๊ธฐ ์ง์ฐ ์๊ฐ์ 15ms์ธ ๋ฐ๋ฉด ์นด์ฐ๋๋ผ๋ 40-125ms์
๋๋ค. p99 ์ฐ๊ธฐ ์ง์ฐ ์๊ฐ์ 5ms์ธ๋ฐ ๋ฐํด ์นด์ฐ๋๋ผ๋ 5-70ms์
๋๋ค.
### ๋์์ ๋ผ์ด๋ธ ์คํธ๋ฆฌ๋ฐ์ YouTube, TikTok ๋ผ์ด๋ธ, Twitch์์ ์ด๋ป๊ฒ ์๋ํ๋์?
@@ -1719,7 +1719,7 @@ ScyllaDB์ p99 ์ฝ๊ธฐ ์ง์ฐ ์๊ฐ์ 15ms์ธ ๋ฐ๋ฉด Cassandra๋ 40-125ms์
3๋จ๊ณ: ์ธ์ฝ๋ฉ๋ ๋ฐ์ดํฐ๋ ๋ณดํต ๋ช ์ด ๊ธธ์ด์ ์์ ์ธ๊ทธ๋จผํธ๋ก ๋๋๊ธฐ ๋๋ฌธ์ ๋ค์ด๋ก๋๋ ์คํธ๋ฆฌ๋ฐ์ ๊ฑธ๋ฆฌ๋ ์๊ฐ์ ํจ์ฌ ์งง์ต๋๋ค.
-4๋จ๊ณ: ์ธ๊ทธ๋จผํธํ๋ ๋ฐ์ดํฐ๋ ์คํธ๋ฆฌ๋ฐ ์๋ฒ๋ก ์ ์ก๋ฉ๋๋ค. ์คํธ๋ฆฌ๋ฐ ์๋ฒ๋ ๋ค์ํ ๋๋ฐ์ด์ค์ ๋คํธ์ํฌ ์กฐ๊ฑด์ ์ง์ํด์ผ ํฉ๋๋ค. ์ด๋ฅผ 'โAdaptive Bitrate Streaming'์ด๋ผ๊ณ ํฉ๋๋ค. ์ฆ, 2๋จ๊ณ์ 3๋จ๊ณ์์ ์๋ก ๋ค๋ฅธ ๋นํธ๋ ์ดํธ๋ก ์ฌ๋ฌ ๊ฐ์ ํ์ผ์ ์์ฑํด์ผ ํฉ๋๋ค.
+4๋จ๊ณ: ์ธ๊ทธ๋จผํธํ๋ ๋ฐ์ดํฐ๋ ์คํธ๋ฆฌ๋ฐ ์๋ฒ๋ก ์ ์ก๋ฉ๋๋ค. ์คํธ๋ฆฌ๋ฐ ์๋ฒ๋ ๋ค์ํ ๋๋ฐ์ด์ค์ ๋คํธ์ํฌ ์กฐ๊ฑด์ ์ง์ํด์ผ ํฉ๋๋ค. ์ด๋ฅผ 'Adaptive Bitrate Streaming'์ด๋ผ๊ณ ํฉ๋๋ค. ์ฆ, 2๋จ๊ณ์ 3๋จ๊ณ์์ ์๋ก ๋ค๋ฅธ ๋นํธ๋ ์ดํธ๋ก ์ฌ๋ฌ ๊ฐ์ ํ์ผ์ ์์ฑํด์ผ ํฉ๋๋ค.
5๋จ๊ณ: ๋ผ์ด๋ธ ์คํธ๋ฆฌ๋ฐ ๋ฐ์ดํฐ๋ CDN(Content Delivery Network)์ด ์ง์ํ๋ ์ฃ์ง ์๋ฒ๋ก ํธ์๋๋ฉฐ, ์๋ฐฑ๋ง ๋ช
์ ์์ฒญ์๊ฐ ๊ฐ๊น์ด ์ฃ์ง ์๋ฒ์์ ๋์์์ ์์ฒญํ ์ ์์ต๋๋ค. CDN์ ๋ฐ์ดํฐ ์ ์ก ์ง์ฐ ์๊ฐ์ ํฌ๊ฒ ์ค์ฌ์ค๋๋ค.
@@ -1731,7 +1731,7 @@ ScyllaDB์ p99 ์ฝ๊ธฐ ์ง์ฐ ์๊ฐ์ 15ms์ธ ๋ฐ๋ฉด Cassandra๋ 40-125ms์
- RTMP (Real-Time Messaging Protocol): ์๋๋ Macromedia์์ ํ๋์ ํ๋ ์ด์ด์ ์๋ฒ ๊ฐ์ ๋ฐ์ดํฐ๋ฅผ ์ ์กํ๊ธฐ ์ํด ๊ฐ๋ฐํ์ต๋๋ค. ์ง๊ธ์ ์ธํฐ๋ท์ ํตํ ๋น๋์ค ๋ฐ์ดํฐ ์คํธ๋ฆฌ๋ฐ์ ์ฌ์ฉ๋ฉ๋๋ค. Skype์ ๊ฐ์ ํ์ ํ์ ์ ํ๋ฆฌ์ผ์ด์
์ ์ง์ฐ ์๊ฐ์ ์ค์ด๊ธฐ ์ํด RTC(Real-Time Communication) ํ๋กํ ์ฝ์ ์ฌ์ฉํ๋ค๋ ์ ์ ์ ์ํ์ธ์.
- HLS (HTTP Live Streaming): H.264 ๋๋ H.265 ์ธ์ฝ๋ฉ์ด ํ์ํฉ๋๋ค. Apple ์ฅ์น๋ HLS ํฌ๋งท๋ง ํ์ฉํฉ๋๋ค.
-- DASH (Dynamic Adaptive Streaming over HTTP): DASH๋ Apple ์ฅ์น๋ฅผ ์ง์ํ์ง ์์ต๋๋ค.
+- DASH (Dynamic Adaptive Streaming over HTTP): DASH๋ Apple ์ฅ์น๋ฅผ ์ง์ํ์ง ์์ต๋๋ค.
- HLS์ DASH๋ ๋ชจ๋ ์ด๋ํฐ๋ธ ๋นํธ๋ ์ดํธ ์คํธ๋ฆฌ๋ฐ์ ์ง์ํฉ๋๋ค.
## License
From e35c7f3c6b5b72758fa3ba11ede5f78202f58946 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=EC=98=A4=EB=B3=91=EC=A7=84?=
<64676070+sunrabbit123@users.noreply.github.com>
Date: Tue, 27 Feb 2024 12:16:09 +0900
Subject: [PATCH 16/16] =?UTF-8?q?fix:=20enhance=20expression(=EC=9E=A0?=
=?UTF-8?q?=EA=B8=88=20=EC=97=86=EB=8A=94=20=EB=B2=84=ED=8D=BC=20->=20?=
=?UTF-8?q?=EB=9D=BD=ED=94=84=EB=A6=AC=20=EB=B2=84=ED=8D=BC)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
translations/README-kr.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/translations/README-kr.md b/translations/README-kr.md
index be66c11..782c1fa 100644
--- a/translations/README-kr.md
+++ b/translations/README-kr.md
@@ -253,7 +253,7 @@ Pagination
Asynchronous Logging
-๋๊ธฐ์ ๋ก๊น
์ ๋ชจ๋ ํธ์ถ์ ๋ํด ๋์คํฌ๋ฅผ ์ฒ๋ฆฌํ๋ฏ๋ก ์์คํ
์๋๊ฐ ๋๋ ค์ง ์ ์์ต๋๋ค. ๋น๋๊ธฐ ๋ก๊น
์ ๋ก๊ทธ๋ฅผ ์ ๊ธ ์๋ ๋ฒํผ๋ก ๋จผ์ ์ ์กํ ํ ์ฆ์ ๋ฐํํฉ๋๋ค. ๋ก๊ทธ๋ ์ฃผ๊ธฐ์ ์ผ๋ก ๋์คํฌ์ ํ๋ฌ์๋ฉ๋๋ค. ๋ฐ๋ผ์ I/O ์ค๋ฒํค๋๊ฐ ํฌ๊ฒ ์ค์ด๋ญ๋๋ค.
+๋๊ธฐ์ ๋ก๊น
์ ๋ชจ๋ ํธ์ถ์ ๋ํด ๋์คํฌ๋ฅผ ์ฒ๋ฆฌํ๋ฏ๋ก ์์คํ
์๋๊ฐ ๋๋ ค์ง ์ ์์ต๋๋ค. ๋น๋๊ธฐ ๋ก๊น
์ ๋ก๊ทธ๋ฅผ ๋ฝํ๋ฆฌ(lock-free) ๋ฒํผ๋ก ๋จผ์ ์ ์กํ ํ ์ฆ์ ๋ฐํํฉ๋๋ค. ๋ก๊ทธ๋ ์ฃผ๊ธฐ์ ์ผ๋ก ๋์คํฌ์ ํ๋ฌ์๋ฉ๋๋ค. ๋ฐ๋ผ์ I/O ์ค๋ฒํค๋๊ฐ ํฌ๊ฒ ์ค์ด๋ญ๋๋ค.
Caching