Write a script that creates a tarball of a given user home directory. The script can take the username as argument; otherwise, the script will prompt for it. The archive will be stored in /tmp with the date in the file name.

요구사항 정리:

• 사용자 이름을 인자로 받기
• 인자가 없으면 프롬프트로 입력받기
• 해당 사용자의 홈 디렉토리를 tar로 압축
• /tmp 에 저장
• 파일 이름에 날짜 포함

1) archive.sh 파일 생성

$ nano archive.sh

#!/bin/bash

# 1. 사용자 이름이 인자로 들어왔는지 확인
if [ -n "$1" ]; then
    USERNAME="$1"
else
    read -p "Enter username: " USERNAME
fi

# 2. 홈 디렉토리 경로 설정
HOME_DIR="/home/$USERNAME"

# 3. 사용자가 존재하는지 확인
if [ ! -d "$HOME_DIR" ]; then
    echo "Error: User home directory does not exist."
    exit 1
fi

# 4. 날짜 생성 (YYYYMMDD 형식)
DATE=$(date +%Y%m%d)

# 5. 아카이브 파일 이름 설정
ARCHIVE_NAME="/tmp/${USERNAME}_home_${DATE}.tar.gz"

# 6. tarball 생성
tar -czf "$ARCHIVE_NAME" "$HOME_DIR"

# 7. 완료 메시지
echo "Archive created: $ARCHIVE_NAME"

2) 실행 권한 주기

$ chmod +x archive.sh

3) 인자없이 실행

$ ./archive.sh

이름 입력

4) 결과

hyunah@hyunah-VMware-Virtual-Platform:~$ ./archive.sh
Enter username: hyunah
tar: Removing leading `/' from member names
tar: /home/hyunah/.cache/ibus/dbus-WE4vOIwr: socket ignored
tar: /home/hyunah/.cache/ibus/dbus-YBwpaXcG: socket ignored
tar: /home/hyunah/.cache/ibus/dbus-0DB5uqCN: socket ignored
tar: /home/hyunah/.cache/ibus/dbus-rMCaQ34F: socket ignored
Archive created: /tmp/hyunah_home_20260303.tar.gz

2 - TBBT

You have just ripped off a DVD of the first season of one of your favorite TV shows. The files are named as "Chapter XX.avi". You want to get all these files renamed as "XX - Episode name.avi". Write a script that reads episode names from a eplist.txt file (one episode per line, sorted chronologically): Pilot The Big Bran Hypothesis The Fuzzy Boots Corollary The Luminous Fish Effect The Hamburger Postulate The Middle-Earth Paradigm The Dumpling Paradox The Grasshopper Experiment The Cooper-Hofstadter Polarization The Loobenfeld Decay The Pancake Batter Anomaly The Jerusalem Duality The Bat Jar Conjecture The Nerdvana Annihilation The Pork Chop Indeterminacy The Peanut Reaction The Tangerine Factor This file does not contain episode numbers, only titles. The script should compute new names for each file, show a renaming proposition and ask user for confirmation before actually renaming.

요구사항 정리:

• 현재 파일명: Chapter XX.avi
• 변경할 파일명: XX - Episode name.avi
• 에피소드 제목은 eplist.txt에서 한 줄씩 읽음
• 실제 변경 전에 미리 보여주고 사용자 확인 받기

1) eplist.txt 생성

nano eplist.txt

Pilot
The Big Bran Hypothesis
The Fuzzy Boots Corollary
The Luminous Fish Effect
The Hamburger Postulate
The Middle-Earth Paradigm
The Dumpling Paradox
The Grasshopper Experiment
The Cooper-Hofstadter Polarization
The Loobenfeld Decay
The Pancake Batter Anomaly
The Jerusalem Duality
The Bat Jar Conjecture
The Nerdvana Annihilation
The Pork Chop Indeterminacy
The Peanut Reaction
The Tangerine Factor

2) rename.sh 생성

nano rename.sh

#!/bin/bash

# TBBT Episode Rename Script
# 기존 파일이 없어도 제안 출력 가능

EPFILE="eplist.txt"

# 1. eplist.txt 존재 확인
if [ ! -f "$EPFILE" ]; then
    echo "Error: $EPFILE not found."
    exit 1
fi

# 2. eplist.txt 라인 수
EP_COUNT=$(wc -l < "$EPFILE")

echo "Proposed renaming:"
echo "-------------------"

i=1
declare -a OLD_NAMES
declare -a NEW_NAMES

# 3. 제안 계산 및 출력 (파일 없어도)
while IFS= read -r TITLE; do
    OLD_NAME=$(printf "Chapter %02d.avi" "$i")
    NEW_NAME=$(printf "%02d - %s.avi" "$i" "$TITLE")

    echo "$OLD_NAME  ->  $NEW_NAME"

    # 실제 rename를 위해 배열에 저장
    OLD_NAMES+=("$OLD_NAME")
    NEW_NAMES+=("$NEW_NAME")

    ((i++))
done < "$EPFILE"

echo
read -p "Proceed with renaming if files exist? (y/n): " ANSWER

if [[ "$ANSWER" =~ ^[Yy]$ ]]; then
    # 실제 파일이 있을 경우만 rename
    for idx in "${!OLD_NAMES[@]}"; do
        if [ -f "${OLD_NAMES[$idx]}" ]; then
            mv "${OLD_NAMES[$idx]}" "${NEW_NAMES[$idx]}"
        fi
    done
    echo "Renaming completed for existing files."
else
    echo "Operation cancelled."
fi

3) 실행 권한 주기

$ chmod +x rename.sh

4) 실행

$ ./rename.sh

5) 결과

hyunah@hyunah-VMware-Virtual-Platform:~$ ./rename.sh
Proposed renaming:
-------------------
Chapter 01.avi  ->  01 - Pilot.avi
Chapter 02.avi  ->  02 - The Big Bran Hypothesis.avi
Chapter 03.avi  ->  03 - The Fuzzy Boots Corollary.avi
Chapter 04.avi  ->  04 - The Luminous Fish Effect.avi
Chapter 05.avi  ->  05 - The Hamburger Postulate.avi
Chapter 06.avi  ->  06 - The Middle-Earth Paradigm.avi
Chapter 07.avi  ->  07 - The Dumpling Paradox.avi
Chapter 08.avi  ->  08 - The Grasshopper Experiment.avi
Chapter 09.avi  ->  09 - The Cooper-Hofstadter Polarization.avi
Chapter 10.avi  ->  10 - The Loobenfeld Decay.avi
Chapter 11.avi  ->  11 - The Pancake Batter Anomaly.avi
Chapter 12.avi  ->  12 - The Jerusalem Duality.avi
Chapter 13.avi  ->  13 - The Bat Jar Conjecture.avi
Chapter 14.avi  ->  14 - The Nerdvana Annihilation.avi
Chapter 15.avi  ->  15 - The Pork Chop Indeterminacy.avi
Chapter 16.avi  ->  16 - The Peanut Reaction.avi
Chapter 17.avi  ->  17 - The Tangerine Factor.avi

Proceed with renaming if files exist? (y/n): y
Renaming completed for existing files.

1. 스프링 부트 프로젝트 configuration

Se rendre sur https://start.spring.io et configurer le projet à générer de la manière suivante : https://start.spring.io에 들어가서 프로젝트 설정을 해준다

- Project : Gradle - Groovy
- Language : Java
- Spring Boot : dernière version 3.x.x stable
- Packaging : jar
- Java : au plus la version du JDK installé sur votre machine
- Dépendances : "Spring Web"

• java는 본인 버전 선택해주기
• Generate, 다운로드 후 압축 풀기

2. 스프링 부트 앱 만들기

1) lab3.2-springboot 폴더 생성

2) 1.에서 만든 demo 폴더 붙여넣기

3) Application.java 있는 곳에 HelloController.java 파일 만들기

package com.example.demo;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class HelloController {

    @GetMapping("/")
    public String hello() {
        return "Hello from Spring Boot 1 !";
    }
}

3. 터미널 열어서 빌드하기

.\gradlew.bat clean bootJar        

• 빌드가 성공적으로 됐으면 build/libs에 .jar 파일이 생긴다

4. Dockerfile 만들기

FROM amazoncorretto:21
WORKDIR /app
COPY build/libs/demo-0.0.1-SNAPSHOT.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]

5. 도커 이미지 만들기

docker build -t lab3.2-springboot .

6. 도커 컨테이너 실행하기

docker run -p 8080:8080 --name lab3.2-springboot lab3.2-springboot

• docker desktop에서 돌아가는 거 확인

7. localhost:8080 확인

Hello from Spring Boot 1 ! 뜨면 정상 작동되는 것작동되는 것

1. Express 앱 만들기

1) lab3.1-express 폴더 생성 (VS Code 사용)

2) 터미널에서 express, ulid 설치

npm install express ulid

3) server.js 파일 생성

const express = require('express');
const { ulid } = require('ulid');

const app = express();

// JSON 파싱을 위해 필요
app.use(express.json());

// 기본 라우트
app.get('/', (req, res) => {
  res.send('Hello, Express!');
});

// JSON 반환 라우트
app.get('/api/data', (req, res) => {
  res.json({
    message: 'JSON data',
    id: ulid()
  });
});

// JSON 받는 라우트
app.post('/api/echo', (req, res) => {
  const receivedData = req.body;
  res.json({
    message: 'Received Data',
    data: receivedData
  });
});

app.listen(3000, () => {
  console.log('Server on http://localhost:3000');
});

2. 로컬에서 express 앱 작동 확인

1) 터미널에서 node server.js로 실행

2) (GET) localhost:3000, (GET) localhost:3000/api/data 확인

3) (POST) localhost:3000/api/echo 확인 (Postman 사용)

3. Dockerfile 작성

(컨테이너로 만들기 위한 문서)

FROM node:20-alpine
WORKDIR /app
COPY . .
# os에 있는 기본 shell 사용함
# RUN npm install
RUN ["npm", "install"]
EXPOSE 3000
CMD ["node", "server.js"]

4. Docker 이미지 빌드

docker build -t lab3.1-express .

5. 컨테이너 실행

docker run --name lab3.1-express -p 3000:3000 lab3.1-express

6. 컨테이너에서 테스트

"2. 로컬에서 express 앱 작동 확인"과 똑같이 확인해주면 된다 로컬에서 작동하는 건지, 컨테이너에서 작동하는 건지 확인해보고 싶다면 컨테이너를 멈추고 테스트해보면 된다!

(Se rendre sur le Docker Hub et rechercher l'image officielle Redis)

2. 받은 Redis 이미지 Run해서 Redis 컨테이너 실행하기

(Lancer un conteneur Redis nommé redis-db et qui publie le port 6379. Se renseigner sur les options de configuration disponibles via les variables d’environnement)

• 컨테이너 이름 : redis-db
• 포트 : 6379

docker run -d --name redis-db -p 6379:6379 redis:latest

간단한 비밀번호 추가 방법 👇

• Redis 공식 이미지는 환경변수로 비밀번호 설정을 지원하지 않음 대신 redis-server 실행 옵션으로 설정 개발/실습 환경에서 간단하게 보안 추가할 때 자주 사용

  docker run -d --name redis-db -p 6379:6379 redis:latest redis-server --requirepass 5763

  

3. JavaScript(Node.js)로 Redis 연결하기

1) lab2.3-node-app-redis 폴더 생성 (VS Code 사용)

2) Node.js Redis 라이브러리 설치

npm init -y
npm install redis

3) index.js 파일 추가

const redis = require('redis');

async function main() {
    const client = redis.createClient({
        url: 'redis://localhost:6379' // 비밀번호가 있다면: redis://:mypassword@redis-db:6379
    });

    client.on('error', (err) => {
        console.error('Redis Client Error', err);
    });

    try {
        await client.connect();

        await client.set('foo', 'bar');
        const value = await client.get('foo');
        console.log("The value of 'foo' is :", value);

    } catch (err) {
        console.error("Error:", err);
    } finally {
        await client.quit();
    }
}

main();

4) VS Code에서 index.js 실행

node index.js

Google Cloud Virtual Private Cloud

• 전세계 단위로 동작하는 가상 네트워크
• 전역(Global) 단위 : 특정 region에 종속되지 않음
• Subnets은 지역(Region) 단위
• VPC는 기본적으로 서로 통신하지 X : Peering, VPN, Interconnect, Shared VPC로 연결 필요
• 같은 Subnet = 같은 Region : 같은 Region 안의 여러 Zone이 같은 서브넷을 공유
• 같은 VPC 안에 있으면 다른 Region이어도 서로 통신이 가능하지만, 같은 Region이어도 다른 VPC 면 인터넷을 통해서 통신해야된다

1) Subnet Creation Mode

• Custom Subnet Mode
  • 운영 환경에서 추천
  • 관리자가 Subnet을 직접 생성
  • IP 범위 겹침 방지
  • Firewall rules 없음
• Auto Subnet Mode
  • 테스트 환경에서 추천
  • 프로젝트 생성 시 생성되는 기본 VPC
  • 모든 Region에 /20 Subnet 자동 생성
  • Region 추가될 때마다 자동으로 Subnet 추가됨
  • 기본 Firewall rules 포함(TCP 22 등)

2) Shared VPC

한 조직 안에서 여러 프로젝트가 하나의 '중앙 VPC'를 공유하는 구조

• Host Project 실제 VPC가 있는 프로젝트 서브넷 생성 담당
• Service Projects 애플리케이션이 배치되는 프로젝트 네트워크 리소스는 중앙 팀에서 관리 서브넷을 사용만 가능
• 목적 회사 여러 팀이 동일 네트워크 정책을 써야 할 때 기업 네트워크 구조 중앙화 CIDR 충돌 방지 보안 및 감사 중앙 집중 대규모 기업, 팀 구조에 최적화
• 특징 조직 내부에서만 작동 네트워크 관리자는 Host Project만 관리 Service Project는 VPC 수정 불가 VM은 Service Project에 만들지만 Subnet은 Host Project에만 존재
• 보안 및 라우팅 같은 VPC 내부이므로 전부 자동 라우팅 firewall, routes 모두 한 네트워크이므로 관리 용이
• 시험 포인트 서브넷 생성은 Host Project에서만 가능 Service Project는 Subnet을 "사용"만 가능 Shared VPC는 조직(Organization) 내부에서만 사용 가능 Cross-organization 불가

3) VPC Network Peering

두 VPC 간 private IP 기반 통신 연결을 제공

• 목적 빠르게 두 VPC를 private으로 연결 네트워크를 합치지 않고도 통신 가능 서로 다른 조직, 프로젝트 간 통신 가능
• 특징 같은 Region일 필요 없음 네트워크 간 격리된 상태에서 private 연결 -> 회계, 보안 분리를 유지하면서 통신 필요할 때 적합 트랜짓(transit) 불가 : a-b, b-c 여도 a-c 통신 불가능
• 언제 사용? 서로 다른 프로젝트 간 private 연결이 필요할 때 SaaS 제공 업체와 private 연결이 필요할 때 통합 네트워크는 필요 없지만 private 통신만 필요한 경우
• 시험 포인트 peering은 양방향 설정 필요 Firewall Rule 필요 peering은 네트워크를 완전히 합치는 것이 X

4) Cloud VPN

VPN(IPsec)을 사용해 온프레미스 또는 외부 네트워크 ↔ GCP VPC를 안전하게 연결하는 서비스

• 목적 온프레미스 <-> GCP 간 사설 통신 외부 클라우드 <-> GCP 통신 빠른 하이브리드 클라우드 구성
• 종류 Classic VPN HA VPN(99.99% SLA)
• 특징 Public internet 위에서 암호화된 터널

1.5~3Gbps per tunnel 여러 터널로 확장 가능 (ECMP)

• 언제 사용? 온프레미스와 GCP를 빠르게 연결할 때 기업 내부망과 GCP를 사설 통신으로 묶을 때 Dedicated Interconnect 하기에는 비용/시간이 부족할 때
• 시험 포인트 Cloud VPN은 인터넷을 사용 : public internet 위에서 IPsec 사용 Cloud VPN은 사설 IP 연결 가능 Classic VPN은 SLA 없음 HA VPN은 SLA 99.99% VPN은 cross-organization도 가능

Q. In GCP, subnets are used mostly for IP addressing purposes. GCP Subnet은 주로 VM에 내부 IP를 할당하기 위한 Pool(IP Range)을 제공하는 목적이 가장 크다. GCP의 Subnet = 특정 Region에서 사용할 IP 주소 덩어리(CIDR Block)

cf) 온프레미스(On-premises)란? 조직 내부 건물(데이터센터, 서버실)에 하드웨어를 두고 직접 인프라를 관리·운영하는 방식

2. DNS

Domain Name System 도메인 이름을 IP 주소로 바꿔주는 시스템 예) www.google.com → 142.250.72.238 api.mycompany.com → 10.20.1.15 사람은 도메인이 기억하기 쉽고, 컴퓨터는 IP가 필요하므로 DNS가 둘 사이를 변환해주는 전화번호부 역할을 한다

GCP 내부에서 VM이 DNS 조회를 할 때 VM이 직접 DNS 서버를 설정하지 않는다 대신, 169.254.169.254 (Metadata Server) 이 주소가 자동으로 DNS Resolver 역할을 한다

• 왜 Metadata Server가 DNS Resolver? GCP가 VM에 내부 DNS 정보를 통제하기 쉽기 때문 Internal DNS / Cloud DNS Private Zone 모두 여기로 라우팅됨 VM에 공통된 DNS 구조 제공
• VM은 반드시 Metadata Server를 통해 DNS 요청을 한다*

VM이 부팅되면 DHCP로 IP 주소와 함께 DNS 서버 주소(= Metadata Server)가 자동 제공된다 즉,따로 DNS 설정을 하지 않아도 GCP가 VM 네트워크 설정을 자동 구성 Internal DNS 및 Private Zone 조회 가능

1) Internal DNS

GCP가 VPC 내부에서 기본으로 제공하는 DNS 서비스 VM을 만들면 GCP가 자동으로 내부 DNS 이름을 만든다

• 특징 같은 프로젝트, 같은 VPC 내부에서만 조회 가능 -> 다른 프로젝트나 다른 VPC에서는 Internal DNS 이름을 알 수 없음, 다른 VPC에서도 조회하려면 DNS Peering 필요 Google이 자동 생성 VM primary internal IP 기반
• 쓰는 이유 VM끼리 IP가 아니라 이름으로 통신 가능 VM IP가 바뀌어도 이름은 유지 (재생성 전까지)

2) Cloud DNS

Google Cloud가 제공하는 공식 DNS 서비스로 성능과 안정성이 매우 뛰어나다.

• Public DNS Zone 인터넷 공개용 도메인 예) www.mycompany.com
• Private DNS Zone GCP 내부 VPC에서만 보이는 도메인 VPC 내부에서만 보이는 DNS 영역 예) erp-back-end1.eu.local 10.10.0.100 erp-back-end2.eu.local 10.10.0.101 내부 전용 Application Load Balancer에도 사용 GCP VPC는 Global이기 때문에 Private DNS Zone도 Global하게 적용된다 : VPC 전체(여러 Region 포함)에서 동일하게 사용 가능 : subnet이 어디 있든 같은 private zone 조회 가능 같은 프로젝트, 같은 VPC에 속해있어야 조회 가능 -> 다른 VPC에서 조회하려면 DNS Peering 필요
• 특징 완전 관리형 고성능 (Google 글로벌 DNS 인프라) Anycast 기반 100% SLA

3. Cloud CDN

CDN(Content Delivery Network)은 전 세계 여러 위치에 분산된 서버 네트워크를 이용해, 사용자에게 웹사이트, 이미지, 동영상 등 콘텐츠를 더 빠르고 안정적으로 전달하는 기술 반드시 Cloud Load Balancer 필요

• 기본 구성 요소

  • Origin Server (오리진 서버) 원래 콘텐츠가 저장된 서버 예: 웹사이트의 이미지, HTML, 동영상 등
  • Cache Server (캐시 서버) 콘텐츠를 복제해서 저장하는 서버 사용자가 요청하면 오리진 서버가 아니라 캐시 서버에서 콘텐츠를 전달

• CDN의 장점 사용자 가까이에서 콘텐츠 제공 → 지연 시간(latency) 감소 → 빠른 웹/앱 대역폭 절약 → 트래픽이 많은 사이트에 유리 오리진 서버 부담 감소 → 서버 안정성 향상 서버 네트워크가 분산되고 중복되어 가용성 증가

• 작동 방식

  • 사용자가 요청 → 가장 가까운 엣지 서버(Edge Server) 확인
  • 캐시 히트(Cache Hit) 콘텐츠가 이미 캐시에 있음 → 바로 사용자에게 제공 → 빠름
  • 캐시 미스(Cache Miss) 콘텐츠가 캐시에 없음 → 오리진 서버에서 가져와 캐시에 저장 후 제공

4. Connectivity

Hybrid Connectivity 온프레미스(On-prem 데이터센터), 다른 클라우드, GCP VPC 를 하나의 네트워크처럼 연결하는 전체 통신 구조 42 Regions, 127 Zones

POP이란? Point of Presence 구글 네트워크 장비가 실제의 물리적 네트워크 시설에 설치된 위치

1) Public Internet VPN (IPsec VPN tunnel)

Encrypted tunnel to VPC networks through the public internet 인터넷 위에서 IPSEC VPN 터널로 사설 네트워크 연결 cloud에, cloud 끼리 연결하는 가장 빠른 방법 속도 1.5 ~ 3 Gbps per tunnel static/dynamic (BGP) based VPN 비용 제일 저렴

2) Cloud Interconnect (전용 회선)

• Dedicated Dedicated, direct connection to VPC networks Higher bandwidth needs (10 Gbps or 100 Gbps per link)
• Partner Dedicated bandwidth, connection to VPC network through a service provider 50 Mbps –10 Gbps per connection

3) Peering

5. Load Balancing

사용자 트래픽을 여러 백엔드 서버에 자동 분산하여 가용성·확장성·성능을 확보하는 서비스

• Layer 7 (Application LB)

• Layer 4 (Network LB)

6. Firewalls

VPC 네트워크 단위로 적용되는 상태 기반(Stateful) 분산 방화벽

• Ingress and Egress firewall (allow / deny rules)

• Stateful with Connection tracking

• Distributed: enforced on host => no choke points

• Flexible grouping mechanism for applications: tags, service accounts

• No support for dest IP match on ingress FW. no support for source IP match on egress FW

• Ingress 외부 -> VM 들어오는 트래픽

• Egress VM -> 외부 나가는 트래픽

• 요소 Direction : INGRESS / EGRESS Priority : 숫자 낮을수록 우선 Target : 적용 대상 VM (Tag, SA) Source/Destination : IP 또는 subnet Allow/Deny : permit / 차단

"postgres" 라고 검색해야 나온다

2. 받은 postgres 이미지 Run해서 postgres 컨테이너 실행하기

• 컨테이너 이름 : postgresql-db
• 포트 : 5432
• 비밀번호 지정

  docker run --name postgresql-db -e POSTGRES_USER=hyunahpark -e POSTGRES_PASSWORD=pw57
  63 -e POSTGRES_DB=my-postgres-db -p 5432:5432 -d postgres:latest

• --name postgresql-db : 컨테이너 이름
• -e POSTGRES_PASSWORD=비밀번호넣기 : postgres 사용자 비밀번호 설정
• -p 5432:5432 : 호스트 ↔ 컨테이너 포트 매핑
• -d : 백그라운드 실행

3. JavaScript(Node.js)로 PostgreSQL 연결하기

1) 프로젝트 폴더 만들기 (VS Code 사용)

lab2.2-postgres

2) pg 패키지 설치

npm install pg

3) index.js 파일 생성, 작성하기

테이블 생성, 데이터 삽입, 데이터 조회 기능

// container : postgresql-db

const { Client } = require('pg');

// 주의할 점 : 2번에서 docker run할 때 설정했던 정보대로 넣어줘야 접속이 된다 (user, password, db)
const client = new Client({
  user: 'hyunahpark',
  host: '127.0.0.1',  // 여기서 로컬 PC의 Docker 포트로 연결
  database: 'my-postgres-db',
  password: 'pw5763',
  port: 5432
});

async function main() {
  try {
    await client.connect();
    console.log('PostgreSQL 연결 성공');

     // 1️⃣ 테이블 생성
    await client.query(`
      CREATE TABLE IF NOT EXISTS users (
        id SERIAL PRIMARY KEY,
        name VARCHAR(50) UNIQUE,
        age INT
      );
    `);
    console.log('테이블 생성 완료');

    // 2️⃣ 데이터 삽입
    await client.query(`
      INSERT INTO users (name, age) VALUES
      ('Alice', 25),
      ('Bob', 30)
      ON CONFLICT DO NOTHING;
    `);

    console.log('데이터 삽입 완료');

    // 3️⃣ 데이터 조회
    const res = await client.query('SELECT * FROM users;');
    console.log('조회 결과:', res.rows);

  } catch (err) {
    console.error('연결 오류:', err);
  } finally {
    await client.end();
  }
}

main();

4) VS Code에서 index.js 실행

node index.js

5) 결과

PostgreSQL 연결 성공
테이블 생성 완료
데이터 삽입 완료
조회 결과: [ { id: 1, name: 'Alice', age: 25 }, { id: 2, name: 'Bob', age: 30 } ]

+ 터미널에서 데이터베이스 직접 접속하는 방법

docker exec -it postgresql-db psql -U hyunahpark -d my-postgres-db

• docker "postgresql-db" 컨테이너 안에서
• psql 실행
• "hyunahpark" 사용자로
• "my-postgres-db" DB에 접속

C:\Users\hyuna\3DOKR\lab2.2-postgres>docker exec -it postgresql-db psql -U hyunahpark -d my-postgres-db
psql (18.1 (Debian 18.1-1.pgdg13+2))
Type "help" for help.

my-postgres-db=# select * from users
my-postgres-db-# ;
 id | name  | age 
----+-------+-----
  1 | Alice |  25
  2 | Bob   |  30
(2 rows)

+ VS Code에서 데이터베이스 테이블 보기

1) SQL Tools PostgreSQL 이라는 extension 다운로드 하기

2) Add connections 눌러서 db 이름, 사용자 이름, 포트 등 설정해주고 비밀번호 입력해주면 된다

3) 결과 이렇게 왼쪽 메뉴에 SQL Tools 메뉴가 생기는데 여기서 Table을 표로 볼 수 있다

Redis는 인메모리 데이터베이스입니다. → 즉, 데이터를 RAM(메모리)에 저장해서 엄청 빠르게 읽고 쓸 수 있어요.

주로 캐시(cache), 세션 저장, 실시간 카운트, 메시지 큐 등에 사용됩니다.

2️⃣ 특징

• 속도 메모리에 저장되므로 읽기/쓰기 속도가 매우 빠름
• 데이터 구조 문자열(String), 리스트(List), 셋(Set), 해시(Hash) 등 다양한 구조 지원
• 영속성 기본은 메모리 저장이지만, 필요하면 디스크에 저장 가능 간단한 키-값 저장소 : GET key, SET key value처럼 간단하게 사용 가능

3️⃣ Redis가 현업에서 인기 있는 이유

Redis는 현업에서 특히 웹 서비스, 게임, 금융, 이커머스 등 다양한 분야에서 광범위하게 활용된다.

• 초고속 성능 메모리에 데이터를 저장하므로 읽기/쓰기 속도가 매우 빠름 예: 페이지 조회수, 실시간 랭킹, 채팅 메시지
• 다양한 데이터 구조 지원 문자열, 리스트, 셋, 해시, 정렬된 셋 등 단순 키-값뿐 아니라 복잡한 데이터 구조도 효율적으로 처리 가능
• 세션 관리 웹 서비스에서 사용자 로그인 세션을 저장할 때 많이 사용 여러 서버에서 세션을 공유할 수 있어 확장성 좋음
• 캐시(Cache) 용도로 최적 데이터베이스 조회 결과를 Redis에 캐싱해서 DB 부하 감소 예: 인기 게시글, 상품 정보, API 결과
• 메시지 브로커 / 큐 Pub/Sub(발행/구독) 기능으로 실시간 알림, 채팅 구현 가능 작업 큐(Task Queue)로도 활용 가능

4️⃣ 현업 사용 예시

• 이커머스
  상품 조회수 카운트, 장바구니 임시 저장, 추천 캐시
• 소셜미디어
  실시간 좋아요/댓글 카운트, 팔로워 알림
• 게임
  랭킹 순위, 실시간 점수, 매칭 큐
• 금융/핀테크
  트랜잭션 임시 저장, 캐싱, 실시간 통계
• 웹 서비스
  로그인 세션, API 응답 캐시, 페이지 캐싱

즉, Redis는 “속도가 중요한 곳”과 “실시간 데이터가 필요한 곳”에서 거의 필수적으로 사용되는 기술이다.

💡

현업에서는 DB + Redis 조합이 일반적이다. DB는 안정적인 저장소, Redis는 빠른 접근과 캐싱 역할

Download Docker Desktop > Download for Windows - AMD64 윈도우 재시작 후 까만 창이 뜨고 리눅스 설치한다고 뜨면 아무 버튼이나 눌러서 설치

• https://git-scm.com/downloads/win 에서 latest 다운로드
• exe 파일 실행해서 설치해주기

2. Git 설치 완료 확인

• 설치가 끝났다면 VS Code 터미널 또는 명령 프롬프트(cmd) 열고 입력:

  git --version

👉 정상이라면 이런 식으로 버전이 표시된다

git version 2.51.0.windows.1

3. 사용자 정보 등록 (처음 한 번만)

👉 “내가 만든 커밋이 누구 것인지” 표시해주는 설정

git config --global user.name "내이름"
git config --global user.email "내이메일@example.com"

(이메일은 GitHub 계정에 등록된 이메일을 사용하는 걸 추천)

4. VS Code에서 GitHub에 올리기

1) VS Code에서 프로젝트 폴더의 터미널 열기

혹은 아무 터미널에서

cd 프로젝트폴더경로

2) Git 초기화

git init

👉 이 명령은 현재 폴더를 Git 저장소로 초기화한다. (폴더 안에 .git이라는 숨김 폴더가 생긴다.)

3) 변경 파일 추가 & 커밋

git add .
git commit -m "Initial commit"

👉 git add . : 모든 파일을 Git에 추적하도록 추가 👉 git commit -m "Initial commit" : 첫 커밋 메시지 작성

4) GitHub에 새 저장소(repository) 만들기

“Initialize this repository with a README”는 체크 X (이미 로컬에 Git 초기화가 되어 있기 때문)

👉 .gitignore는 코드 업로드 전 로컬 저장소에서 만드는 것 추천!! (갓 프로젝트 파일을 만든 거면 상관 없지만 node_modules가 생긴 상태면 .gitignore을 안 만들고 깃허브에 업로드 하면 쓸 데 없는 파일까지 다 업로드 되어버린다)

5) 로컬 프로젝트와 GitHub 연결 & 업로드

git remote add origin https://github.com/사용자이름/my-project.git
git branch -M main
git push -u origin main

👉 GitHub에서 새 저장소를 만들면 위처럼 안내 문구가 나온다. (복사해서 터미널에 붙여넣기!!) 👉 https:// 다음은 본인 깃허브 리퍼지토리 주소로 바꿔주기

6) GitHub 로그인 / Personal Access Token(PAT) 입력

VS Code 내 세 번째 메뉴 "Source Control"에서 "Publish to GitHub" 눌러서 깃허브 로그인 해주기

7) 업로드 완료!

명령이 끝나면 GitHub에 들어가서 새로고침하면 프로젝트 파일이 올라간 것을 볼 수 있다!

👉 나는 6번 로그인을 안 하고 publish를 안 눌러줬더니 안 올라갔었다. 깃허브 처음 연결하는 거라면 잊지 말기!

블로킹(Blocking)

• 어떤 작업이 끝날 때까지 다음 코드가 실행되지 않는 것을 의미
• 쉽게 말해, 작업 중에는 아무것도 못하고 기다리는 상태
• Node.js에서 대표적인 예 : 동기식 파일 읽기(readFileSync)

const fs = require("fs");

console.log("시작");
const data = fs.readFileSync("file.txt", "utf8"); // 여기서 파일 읽는 동안 멈춤
console.log(data);
console.log("끝");

실행 순서: 시작 (파일 읽는 동안 잠시 멈춤) 파일 내용 출력 끝

즉, 파일 읽기가 끝날 때까지 다른 작업이 진행되지 않음 → 서버라면 요청 처리도 멈춰버림

논블로킹(Non-blocking)

• 작업을 시작하고, 끝나길 기다리지 않고 바로 다음 코드 실행
• Node.js에서 주로 콜백(callback), Promise, async/await 방식으로 사용
• 예시 : 비동기 파일 읽기(readFile)

const fs = require("fs");

console.log("시작");
fs.readFile("file.txt", "utf8", (err, data) => {
    console.log(data); // 파일 읽기 끝나면 실행
});
console.log("끝");

실행 순서: 시작 끝 (나중에 파일 내용 출력)

서버에서는 다른 요청 처리를 중간에 멈추지 않고 계속 진행할 수 있음

2️⃣ 핵심 포인트

1. 블로킹 → 작업 완료까지 기다림 → 다른 코드 정지
2. 논블로킹 → 작업 시작 후 바로 다음 코드 실행 → 완료되면 콜백/Promise로 처리
3. Node.js 서버에서는 블로킹 코드를 많이 쓰면 전체 서버 성능 저하

👩‍💻 문제

🙋‍♀️ 답변

let products = [
    {id: 1, name: "Laptop", price: 1200},
    {id: 2, name: "Headphones", price: 150},
    {id: 3, name: "Keyboard", price: 70},
    {id: 4, name: "Mouse", price: 40},
    {id: 5, name: "Monitor", price: 300}
];

// Import the express library
const express = require("express");

// Initializing the app
const app = express();

app.use(express.json());
// app.use() : 요청 바디(request body)를 JSON으로 파싱하는 내장 미들웨어
// express.json()
// : 요청 바디(request body)를 JSON으로 파싱하는 내장 미들웨어
// 클라이언트가 보낸 JSON 데이터를 request.body로 바로 사용할 수 있게 만들어줌

// CREATE
app.post("/products", (request, response)=> {
    const newProduct = request.body; // OBJECT JS
    console.log(newProduct); 
    products.push(newProduct);
    response.status(201).send(products);
    // response.json(products);
});

// READ ALL (+ 필터 기능)
// 쿼리 파라미터 - request.query
app.get("/products", (request, response)=> {

    const query = request.query; // 쿼리 파라미터 전체 가져오기
    console.log(query);

    // let name = query.name;
    // let minPrice = query.minPrice;
    // let maxPrice = query.maxPrice;

    // 객체 구조 분해 할당 (Object destructuring assignment)
    let { name, minPrice, maxPrice } = query;

    // 문자열 -> 숫자 변환
    minPrice = minPrice ? Number(minPrice) : undefined;
    maxPrice = maxPrice ? Number(maxPrice) : undefined;

    // 새로운 배열로 필터링
    let filtered = products;

    // 이름 검색 (부분 일치도)
    if(name) {
        filtered = filtered.filter(p => {
            return p.name.toLowerCase().includes(name.toLowerCase());
        });
    }

    // 최소 가격
    if(minPrice !== undefined) {
        filtered = filtered.filter(p => {
            return p.price >= minPrice
        });
    }

    // 최대 가격
    if(maxPrice) {
        filtered = filtered.filter(p => {
            return p.price <= maxPrice
        });
    }

    response.status(200).json(filtered);
});

// READ ONE
// (경로) 파라미터 - request.params
app.get("/products/:id", (request, response)=> {
    const id = parseInt(request.params.id); // 모든 params 중에 id를 가져온다 (String 형식)
    console.log("Product id : " + id);
    const product = products.find(p=> p.id===id);
    console.log(product);

    if (!product) {
        return response.status(404).send({ message: "Product not found" });
    }

    response.status(200).send(product);
})

// UPDATE
app.put("/products/:id", (request, response)=> {
    const id = parseInt(request.params.id); // 모든 params 중에 id를 가져온다 (String 형식)
    console.log("Product id : " + id);
    const product = products.find(p=> p.id===id);
    console.log(product);

    if (!product) {
        return response.status(404).send({ message: "Product not found" });
    }

    const { name, price } = request.body;

    if(name) product.name = name;
    if(price !== undefined) product.price = price;

    response.status(200).send(product);
});

// DELETE
app.delete("/products/:id", (request, response)=> {
    const id = parseInt(request.params.id); // 모든 params 중에 id를 가져온다 (String 형식)
    console.log("Product id : " + id);
    const product = products.find(p=> p.id===id);

    if (!product) {
        return response.status(404).send({ message: "Product not found" });
    }

    products = products.filter(p=> p.id !== id);

    response.status(200).send(products);
});



app.listen(8080, (err)=> {
    console.log("Server running on http://localhost:8080");
});

🤔

• request.params.id 나 request.body.minPrice 결과가 String이니까 int로 변경해주기
• int로 변경해줬을 때 NaN 뜨지 않게 undefined 처리해주기
• 객체 구조 분해 할당 사용해서 간결하게 하기
• 없는 제품 검색했을 때 404 리턴해주는 게 좋은가? (더 RESTful 하다고 한다) : 어떤 경우에 404 리턴해주고 어떤 경우에 null 리턴해주는 게 좋은지?
• response.send()와 response.json() 사용의 차이

def add_many(*args):
    return sum(args)

print(add_many(1, 2, 3, 4))  # 10

파이썬에서 *args는 가변 위치 인자 variable-length positional arguments 라고 부른다.

☕️ Java

public class Example {
    public static int addMany(int... args) {
        int sum = 0;
        for (int num : args) {
            sum += num;
        }
        return sum;
    }

    public static void main(String[] args) {
        System.out.println(addMany(1, 2, 3, 4));  // 출력: 10
    }
}

자바에서 int... args는 Varargs (variable arguments) 라고 부른다.

a = [1,2,3,4]
result = [num*3 for num in a if num%2 !=0]
print(result)

result = [i*j for i in range(1,10) for j in range(1,10)]
print(result)

결과

[3, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 2, 4, 6, 8, 10, 12, 14, 16, 18, 3, 6, 9, 12, 15, 18, 21, 24, 27, 4, 8, 12, 16, 20, 24, 28, 32, 36, 5, 10, 15, 20, 25, 30, 35, 40, 45, 6, 12, 18, 24, 30, 36, 42, 48, 54, 7, 14, 21, 28, 35, 42, 49, 56, 63, 8, 16, 24, 32, 40, 48, 56, 64, 72, 9, 18, 27, 36, 45, 54, 63, 72, 81]

for i in range(1, 11):
    print(i)

Java ☕️

for (int i = 1; i < 11; i++) {
    System.out.println(i);
}

항상 기본 for문만 사용했었는데 Stream으로 간단하게 한 줄로 가능하다는 것을 알았다...!

import java.util.stream.IntStream;

public class StreamExample {

    public static void main(String[] args) {

        IntStream.range(1, 11).forEach(System.out::println); // 메서드 레퍼런스 방식
        IntStream.range(1, 11).forEach(x->System.out.println(x)); // 람다식
    }

}

람다식도 익숙하지 않아서 아직 잘 못 쓰는데 메서드 레퍼런스 방식은 진짜 모르겠다,,,,😀 간결한 건 좋은데 직관적이지 않아서 더 어렵게 느껴지는 것 같다.

a = [1, 2, 3]
b = a

b.append(4)

print(a)  # 👉 [1, 2, 3, 4]
print(b)  # 👉 [1, 2, 3, 4]
print(a is b)  # 👉 True

Java ☕️

List<Integer> a = new ArrayList<>(List.of(1, 2, 3));
List<Integer> b = a;

b.add(4);

System.out.println(a); // 👉 [1, 2, 3, 4]
System.out.println(b); // 👉 [1, 2, 3, 4]

• 중복을 허용하지 않는다
• 순서가 없다

✔️ 파이썬, 자바로 교집합, 합집합, 차집합 구하기

Python 🐍

a = {1, 2, 3}
b = {2, 3, 4}

print(a & b) 
print(a.intersection(b))  # 교집합: {2, 3}
print(a | b) 
print(a.union(b))         # 합집합: {1, 2, 3, 4}
print(a - b) 
print(a.difference(b))    # 차집합: {1}

Java ☕️

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Set<Integer> a = new HashSet<>(Arrays.asList(1, 2, 3));
        Set<Integer> b = new HashSet<>(Arrays.asList(2, 3, 4));

        // 교집합
        Set<Integer> intersection = new HashSet<>(a);
        intersection.retainAll(b);
        System.out.println("교집합: " + intersection);  // [2, 3]

        // 합집합
        Set<Integer> union = new HashSet<>(a);
        union.addAll(b);
        System.out.println("합집합: " + union);         // [1, 2, 3, 4]

        // 차집합
        Set<Integer> difference = new HashSet<>(a);
        difference.removeAll(b);
        System.out.println("차집합: " + difference);    // [1]
    }
}

이렇게 비교해보니 코드 길이 차이가... 😱 파이썬이 훨씬 간단하고 쉽긴 하다 !!

Python

a = {'name': 'Alice', 'age': 30, 'city': 'Seoul'}

keys = a.keys()
print(keys)           # dict_keys(['name', 'age', 'city'])
print(list(keys))     # ['name', 'age', 'city']

Java

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("name", 1);
        map.put("age", 2);
        map.put("city", 3);

        Set<String> keys = map.keySet();

        System.out.println(keys);  // [name, age, city]
    }
}

map 선언 안 해도 되고 그냥 냅다 써버리는 거 적응 안 된다,,, 파이썬의 첫인상은 유도리가 너무 넘쳐서 당황스러운 느낌... 그래서 오히려 헷갈리는 느낌...😀

📌 Stack 영역

• 메서드 호출 시 생성되는 프레임과 지역 변수가 저장되는 공간입니다.
• 후입선출 (LIFO, Last In First Out) 구조로 동작합니다.
• 메서드가 호출되면 메모리가 자동으로 할당되고, 메서드가 끝나면 자동으로 해제됩니다.
• 속도가 빠르며, 각 스레드마다 독립적인 스택을 가집니다 → 스레드 안전(Thread-safe)

  void example() {
    int x = 10; // x는 Stack에 저장됨
  }

📌 Heap 영역

• new 키워드를 통해 생성된 객체가 저장되는 공간입니다.
• 메모리는 동적으로 할당되며, 가비지 컬렉터(Garbage Collector)가 관리합니다.
• Stack보다 속도가 느리지만, 객체는 프로그램 전반에서 공유될 수 있습니다.
• 여러 스레드가 접근 가능하기 때문에 동기화(synchronization)가 필요할 수 있습니다.

  Person p = new Person(); // p는 Stack에, 실제 Person 객체는 Heap에 저장됨

  🔍 요약 표:

  

🧠 Stack vs Heap in Java

📌 Stack

• The stack is a region of memory that stores method call frames and local variables.
• It follows the Last In, First Out (LIFO) principle.
• Memory is automatically allocated and deallocated when methods are called and return.
• It is faster than the heap.
• Each thread has its own stack, so it's thread-safe.
• Example: When you declare a local variable like int x = 10; inside a method, it's stored in the stack.

📌 Heap

• The heap is a region of memory used for dynamic memory allocation.
• Objects created using new are stored in the heap.
• Memory in the heap is managed by the Garbage Collector.
• It is slower compared to the stack.
• The heap is shared among all threads, so you need to handle synchronization for thread safety.
• Example: When you write Person p = new Person();, the Person object is created in the heap, while the reference p is stored in the stack.

  🔍 Summary Table:

  

🧠 Pile (Stack) vs Tas (Heap) en Java

📌 Pile (Stack)

• La pile est une zone mémoire qui stocke les frames d’appel de méthode et les variables locales.
• Elle suit le principe dernier entré, premier sorti (LIFO).
• La mémoire y est allouée et libérée automatiquement à chaque appel et retour de méthode.
• Elle est plus rapide que le tas.
• Chaque thread dispose de sa propre pile, ce qui la rend thread-safe.
• Exemple : Lorsque vous déclarez une variable locale comme int x = 10; dans une méthode, x est stockée dans la pile.

📌 Tas (Heap)

• Le tas est une zone mémoire utilisée pour l’allocation dynamique.
• Les objets créés avec new sont stockés dans le tas.
• La gestion de la mémoire est assurée par le ramasse-miettes (Garbage Collector).
• Il est plus lent que la pile.
• Le tas est partagé entre tous les threads, donc synchronisation nécessaire pour la sécurité des accès concurrents.
• Exemple : Avec Person p = new Person();, l’objet Person est créé dans le tas, tandis que la référence p est stockée dans la pile.

🔍 Tableau récapitulatif

• 클래스를 사용하여 객체 생성자 정의
• 함수 방식으로 객체 생성자 사용

1. 클래스를 사용한 객체 생성자 (ES6)

ES6부터는 클래스를 사용하여 객체 생성자를 정의할 수 있다. 클래스는 생성자 함수의 새로운 문법적 표현이다.

 <script>
        class Person {
          // 생성자 함수
            constructor(name, age) {
                this.name = name;
                this.age = age;
            }

          // 메서드 정의
            sayHello() {
                console.log(`안녕하세요 ${this.name}`);
            }
        }

        // 객체 생성
        let person1 = new Person("홍길동", 20);

        // 메서드 호출
        person1.sayHello();
    </script>

2-1. 함수 방식으로 객체 생성자 사용 (전통적 방식)

전통적인 객체 생성자 방식은 함수 선언을 사용하여 객체를 생성하는 방법이다. 이 방식에서 new 키워드를 사용하여 객체를 생성한다.

     <script>
          // 객체 생성자 함수 정의
        function Person(name, age) {
            this.name = name;
            this.age = age;
            this.sayHello = function() {
                console.log(`안녕하세요 ${this.name}`);
            };
        }

        // 객체 생성
        let person1 = new Person("홍길동", 30);

        // 메서드 호출
        person1.sayHello();
    </script>

2-2. 프로토타입 사용

객체 생성자 함수에 프로토타입을 사용하여 함수를 등록하면 메모리 낭비를 줄일 수 있다.

    <script>
        function Person(name, age) {
            this.name = name;
            this.age = age;
            // this.sayHello = function() {
            //     console.log(`안녕하세요 ${this.name}`);
            // };     
        }

        Person.prototype.sayHello = function() {
            console.log(`안녕하세요 ${this.name}`);
        }

        let person1 = new Person("박현아", 29);
        person1.sayHello();
    </script>