sejong.jeonjo@gmail.com

작성일: 2023년 7월 16일
IPv6 스터디하면서 참고했던 자료나 기억할 것을 여기에 기록하기

IPv6 주소 표기

• 128 bit
• 16 bit 씩 8자리로 구성. 각 자리는 콜론으로 구분
• 앞 64 bit는 network address, 뒤 64 bit는 장비의 network interface address
  (network address는 64 bit 길이가 아니어도 된다. 더 크거나 더 작아도 된다.)
• IPv6 주소 예시

IPv4, IPv6 Header 구조 비교

IPv6 확장 Header

IPv6 통신 방식 (Network Node 간 통신 방식)

IPv6 주소 종류

Unicast Address 종류

예시: Global Unicast Address

예시: Link Local Unicast Address

Multicast Address

ff00::/8 - IPv6 멀티캐스트를 위한 주소공간이다. IPv4에서 제공했던 브로드캐스트는 IPv6에서는 더 이상 지원되지 않으며, IPv6에서는 대신 멀티캐스트를 사용해야 한다.

IPv6 Multicast Group

Anycast Address

Anycast 통신은 ‘1:가장 가까운 1’간의 통신방식이라고 정의할 수 있다.

동일한 주소를 가지는 여러 목적지 장비들 중 출발지 장비와 가장 가까운 장비가 응답을 하는 통신방식이다.
이러한 통신방식은 멀티캐스트와 유사하지만 멀티캐스트의 경우 동일 그룹에 소속된 장비들이 응답을 하는 반면, 애니캐스트의 경우는 동일 주소를 가지는 장비들 중 가장 가까운 장비 하나만 응답을 한다는 차이가 있다.

IPv4-mapped IPv6 addresses

IPv6 Address Scope 개념

국내 IPv6 관리대행자별 IPv6 주소 목록 (2023.07.17 현재)

Linux (Ubuntu)에서 IPv6 Address 사용

IPv6 Address 설정하기 (nmcli 명령 사용)

## ip addr 명령으로 설정
##   a) IPv6 주소 설정
$ ip -6 addr add 2001:db8:0:1::a00:2/64 dev enp1s0

##   b) IPv6 주소 삭제
$ ip -6 addr del 2001:db8:0:1::a00:2/64 dev enp1s0

##   c) IPv6 주소 확인
$ ip -6 addr show dev enp1s0


## nmcli 명령으로 설정
##   a) Network device list 출력
$  nmcli  dev

##   b) IPv6 주소 설정
$ nmcli  con  mod  ens0  ipv6.address 2001:db8:0:1::a00:1/64  ipv6.gateway 2001:db8:0:1::1

참고 문서   https://www.lesstif.com/system-admin/centos-nmcli-ip-static-ip-98926807.html

IPv6 Address 설정하기 (Gnome GUI 설정 화면 사용)

아래 예시 화면처럼 [IPv6] 설정 탭에서 Address, Prefix, Gateway를 설정한다.

Web Browser로 IPv6 주소의 웹 페이지 조회하기

아래 예제처럼 주소창에 IPv6 주소값을 입력하고 테스트해본다.

http://[2001:db8:0:1::a00:1]:8080/

curl 명령으로 동일하게 테스트할 수 있다. (아래 예제를 참고)

$  curl http://[2001:db8:0:1::a00:1]:8080/

 Hello from example application. (written by Andrew)

$

CURL 명령으로 IPv6 주소 확인하기 (Global scope address)

## 이 장비의 Network port에 설정된 IPv6 주소 열람하기
$  ip -6 addr

## IPv6 주소 중에서 Global scope 주소만 열람하기
$  ip -6 addr show scope global 

## 나의 NAT 장비의 IPv6 인터넷 주소 확인하기
## (참고: NAT에 IPv6가 설정되지 않았으면, IPv4 주소가 출력된다)
$  dig -6 TXT +short o-o.myaddr.l.google.com @ns1.google.com

$  dig -t aaaa +short myip.opendns.com @resolver1.opendns.com

$  curl -6 https://ifconfig.co

$  curl -6 https://ipv6.icanhazip.com  

$  ssh -6 sshmyip.com

IPv4 to IPv6 주소 변환하기

참고 문서:
  KRNIC 스터디 자료 
    https://xn--3e0bx5euxnjje69i70af08bea817g.xn--3e0b707e/jsp/resources/vsix/icmp.jsp
  NDP 설명 영상
    https://www.youtube.com/watch?v=A3LFt7CHpgs
  https://www.minzkn.com/moniwiki/wiki.php/IPv6
  https://en.wikipedia.org/wiki/IPv6_address

아래 예시는 Linux OS에 Hugepage를 적용하는 절차이다.

##
## /etc/default/grub 파일에서  
## default_hugepagesz, hugepagesz, hugepages, transparent_hugepage
## 항목을 추가 설정한다.
## (아래 예시를 참고)
##

$ cat  /etc/default/grub

GRUB_TIMEOUT=5
GRUB_DISTRIBUTOR="$(sed 's, release .*$,,g' /etc/system-release)"
GRUB_DEFAULT=saved
GRUB_DISABLE_SUBMENU=true
GRUB_TERMINAL_OUTPUT="console"
GRUB_CMDLINE_LINUX="crashkernel=auto rhgb quiet default_hugepagesz=1GB hugepagesz=1G hugepages=320 transparent_hugepage=never"
GRUB_DISABLE_RECOVERY="true"
GRUB_ENABLE_BLSCFG=true

$

##
## 위와 같이 /etc/default/grub 파일을 수정하고,
## grub2 명령으로 설정을 적용한다.
##

## Case: UEFI Mode
$ grub2-mkconfig -o /boot/efi/EFI/redhat/grub.cfg

## Case: Legacy BIOS Mode
$ grub2-mkconfig -o /boot/grub2/grub.cfg

##
## 위와 같이 설정 작업을 마무리했으면, OS를 Reboot하여 설정을 반영한다.
##

$ reboot

Go Language로 특정 Process의 CPU, Memory 사용량을 계산하고 싶다면,

아래의 코드를 Build해서 사용하면 된다.

참고: Linux, MacOS, Unix, Windows 모두 동작하는 코드임.

// Filename: proc_usage.go

package main

import (
	"errors"
	"fmt"
	"io/ioutil"
	"math"
	"os/exec"
	"path"
	"runtime"
	"strconv"
	"strings"
	"sync"
)

const (
	statTypePS   = "ps"
	statTypeProc = "proc"
)

// SysInfo will record cpu and memory data
type SysInfo struct {
	CPU    float64
	Memory float64
}

// Stat will store CPU time struct
type Stat struct {
	utime  float64
	stime  float64
	cutime float64
	cstime float64
	start  float64
	rss    float64
	uptime float64
}

type fn func(int) (*SysInfo, error)

var fnMap map[string]fn
var platform string
var history map[int]Stat
var historyLock sync.Mutex
var eol string

// Linux platform
var clkTck float64 = 100    // default
var pageSize float64 = 4096 // default

func init() {
	platform = runtime.GOOS
	if eol = "\n"; strings.Index(platform, "win") == 0 {
		platform = "win"
		eol = "\r\n"
	}
	history = make(map[int]Stat)
	fnMap = make(map[string]fn)
	fnMap["darwin"] = wrapper("ps")
	fnMap["sunos"] = wrapper("ps")
	fnMap["freebsd"] = wrapper("ps")
	fnMap["openbsd"] = wrapper("proc")
	fnMap["aix"] = wrapper("ps")
	fnMap["linux"] = wrapper("proc")
	fnMap["netbsd"] = wrapper("proc")
	fnMap["win"] = wrapper("win")

	if platform == "linux" || platform == "netbsd" || platform == "openbsd" {
		initProc()
	}
}

func initProc() {
	clkTckStdout, err := exec.Command("getconf", "CLK_TCK").Output()
	if err == nil {
		clkTck = parseFloat(formatStdOut(clkTckStdout, 0)[0])
	}

	pageSizeStdout, err := exec.Command("getconf", "PAGESIZE").Output()
	if err == nil {
		pageSize = parseFloat(formatStdOut(pageSizeStdout, 0)[0])
	}

}

func wrapper(statType string) func(pid int) (*SysInfo, error) {
	return func(pid int) (*SysInfo, error) {
		return stat(pid, statType)
	}
}

func formatStdOut(stdout []byte, userfulIndex int) []string {
	infoArr := strings.Split(string(stdout), eol)[userfulIndex]
	ret := strings.Fields(infoArr)
	return ret
}

func parseFloat(val string) float64 {
	floatVal, _ := strconv.ParseFloat(val, 64)
	return floatVal
}

func statFromPS(pid int) (*SysInfo, error) {
	sysInfo := &SysInfo{}
	args := "-o pcpu,rss -p"
	if platform == "aix" {
		args = "-o pcpu,rssize -p"
	}
	stdout, _ := exec.Command("ps", args, strconv.Itoa(pid)).Output()
	ret := formatStdOut(stdout, 1)
	if len(ret) == 0 {
		return sysInfo, errors.New("Can't find process with this PID: " + strconv.Itoa(pid))
	}
	sysInfo.CPU = parseFloat(ret[0])
	sysInfo.Memory = parseFloat(ret[1]) * 1024
	return sysInfo, nil
}

func statFromProc(pid int) (*SysInfo, error) {
	sysInfo := &SysInfo{}
	uptimeFileBytes, err := ioutil.ReadFile(path.Join("/proc", "uptime"))
	if err != nil {
		return nil, err
	}
	uptime := parseFloat(strings.Split(string(uptimeFileBytes), " ")[0])

	procStatFileBytes, err := ioutil.ReadFile(path.Join("/proc", strconv.Itoa(pid), "stat"))
	if err != nil {
		return nil, err
	}
	splitAfter := strings.SplitAfter(string(procStatFileBytes), ")")

	if len(splitAfter) == 0 || len(splitAfter) == 1 {
		return sysInfo, errors.New("Can't find process with this PID: " + strconv.Itoa(pid))
	}
	infos := strings.Split(splitAfter[1], " ")
	stat := &Stat{
		utime:  parseFloat(infos[12]),
		stime:  parseFloat(infos[13]),
		cutime: parseFloat(infos[14]),
		cstime: parseFloat(infos[15]),
		start:  parseFloat(infos[20]) / clkTck,
		rss:    parseFloat(infos[22]),
		uptime: uptime,
	}

	_stime := 0.0
	_utime := 0.0

	historyLock.Lock()
	defer historyLock.Unlock()

	_history := history[pid]

	if _history.stime != 0 {
		_stime = _history.stime
	}

	if _history.utime != 0 {
		_utime = _history.utime
	}
	total := stat.stime - _stime + stat.utime - _utime
	total = total / clkTck

	seconds := stat.start - uptime
	if _history.uptime != 0 {
		seconds = uptime - _history.uptime
	}

	seconds = math.Abs(seconds)
	if seconds == 0 {
		seconds = 1
	}

	history[pid] = *stat
	sysInfo.CPU = (total / seconds) * 100
	sysInfo.Memory = stat.rss * pageSize
	return sysInfo, nil
}

func stat(pid int, statType string) (*SysInfo, error) {
	switch statType {
	case statTypePS:
		return statFromPS(pid)
	case statTypeProc:
		return statFromProc(pid)
	default:
		return nil, fmt.Errorf("Unsupported OS %s", runtime.GOOS)
	}
}

// GetStat will return current system CPU and memory data
func GetStat(pid int) (*SysInfo, error) {
	sysInfo, err := fnMap[platform](pid)
	return sysInfo, err
}

// Filename: main.go

package main

import (
    "os"
    "fmt"
    "time"
    "strconv"
)

func main() {
    myPid, _ := strconv.Atoi(os.Args[1])

    for i:= 0; i < 100; i++ {
        sysInfo, _ := GetStat(myPid)
        fmt.Println("CPU Usage     :", sysInfo.CPU)
        fmt.Println("Mem Usage(RSS):", sysInfo.Memory)
        time.Sleep(5 * time.Second)
    }
}

위와 같이 Go source code를 모두 작성했다면, 아래처럼 build하고 실행하면 된다.

$ go mod init andrew.space/proc_usage
go: creating new go.mod: module andrew.space/proc_usage
go: to add module requirements and sums:
	go mod tidy
    
$ go mod tidy

$ go build

$ ./proc_usage 4314
CPU Usage     : 52.92167225853122
Mem Usage(RSS): 2.018664448e+09
CPU Usage     : 39.800000000000004
Mem Usage(RSS): 2.018664448e+09
CPU Usage     : 47.30538922366738
Mem Usage(RSS): 2.018664448e+09
...
...

top 명령으로 본 것과 결과가 동일했다.

작성일: 2025년 5월 5일

시스템 알람을 발생시키는 테스트를 하거나 Kubernetes의 Horizontal Pod Autoscaler 기능 테스트를 할 때,

CPU 부하를 발생시키는 명령 도구가 있으면 편하다.

아래와 같이 설치하고 테스트하면 된다. (설명은 생략하고, 그냥 따라해보자~)

##
## 설치
##

$ yum install -y stress

$ stress --help
...

##
## 30초 동안 3000ms의 CPU 과부하를 유발하기.
##
$ stress --cpu 3 --timeout 30s

##
## 500MB의 메모리 과부하를 유발하기
##  --vm : Worker 개수
##  --vm-hang : malloc 실행 후 free하기 전까지 sleep할 시간(초)
##
$ stress --vm 1 --vm-bytes 500M --vm-hang 1

또는 아래와 같은 명령 예시를 따라해도 비슷한 효과를 얻을 수 있다.

$ yum install -y stress-ng

## CPU 사용률 70%를 유지하고자 할 경우
$ stress-ng  --cpu 1  --cpu-load 70%  --timeout 10m  --metrics  --times  --verify

블로그 작성자: sejong.jeonjo@gmail.com

작성일: 2024년 2월 16일

프로그래밍을 하다보면, 시간 값으로 "1697180099.123" 이런 형태의 값을 많이 보게된다.

이런 형태의 시간 값을 unix time 또는 epoch time이라고 한다.

1970년 1월 1일 0시 0분 0초를 Unix epoch라고 정의한다.

그리고 이 Unix epoch 이후부터 흐른 시간(초)를 표현한 것이 unix time(epoch time)이다.

그런데 이 Unix time은 컴퓨터가 다루기 좋은 형태일 뿐, 사람은 이 숫자(unix time)를 봐도 몇월 며칠 몇시인지 알 수 없다.

이럴 때 편하게 unix time을 우리가 읽을 수 있는 날짜 형태로 바꾸어는 웹 페이지가 있다.

아래 웹 페이지에서 unix time을 입력하면 사람이 읽기 좋은 형태로 바꾸어준다. 그 반대의 경우가 제공한다.

또는 Linux 명령어 중에 date 명령으로도 쉽게 날짜 형태를 바꿀 수 있다.

$  date -d @1657180059
Thu 07 Jul 2022 04:47:39 PM KST

$  date --date=@0
Thu 01 Jan 1970 09:00:02 AM KST

내가 자주 사용하는 형태는 아래와 예제와 같고, find 명령에 대한 자세한 내용은 아래 Web Docs를 참고할 것 !!!

$ find /proc -maxdepth 2 -name "comm" -print

$ find /proc -maxdepth 2 -name "comm" -exec cat {} \;

$ find . -maxdepth 2 -name "comm" -type f -mmin +1 -print | xargs grep kubelet
./4305/comm:kubelet
$

find 명령과 xargs 명령을 조합해서 사용하려면 많은 내용을 길게 입력해야 하는데, 아래와 같이 미리 .bashrc 파일에 function으로 등록하면 쉽게 이용할 수 있다.

$ cat .bashrc

... 중간 생략 ...

##
## .c 또는 .h 파일에서 특정 문자열을 찾는 함수
##
function find_xargs() {
    find . -name "*\.[ch]" -type f  -print | xargs grep $1
}

... 중간 생략 ...


##
## 위에서 .bashrc 파일에 추가한 내용을 현재 shell 환경에 적용하기
##

$ . .bashrc


## --------------------------------------------------------------

##
## 위에서 작성한 find_xargs 명령을 이용하여 Source code file에서 ip_hdr 함수를 찾는 예제
##

$ find_xargs  ip_hdr

./net/dccp/ipv6.c:		newnp->mcast_hops  = ip_hdr(skb)->ttl;
./net/dccp/ipv4.c:	return secure_dccp_sequence_number(ip_hdr(skb)->daddr,
./net/dccp/ipv4.c:					   ip_hdr(skb)->saddr,
./net/dccp/ipv4.c:	newinet->mc_ttl	   = ip_hdr(skb)->ttl;
./net/dccp/ipv4.c:	const struct iphdr *iph = ip_hdr(skb);
./net/dccp/ipv4.c:	rxiph = ip_hdr(rxskb);
./net/dccp/ipv4.c:	sk_rcv_saddr_set(req_to_sk(req), ip_hdr(skb)->daddr);
./net/dccp/ipv4.c:	sk_daddr_set(req_to_sk(req), ip_hdr(skb)->saddr);
./net/dccp/ipv4.c:	iph = ip_hdr(skb);
./net/sched/act_ipt.c:	iph = ip_hdr(skb);
./net/sched/act_ctinfo.c:		dscp = ipv4_get_dsfield(ip_hdr(skb)) & ~INET_ECN_MASK;
./net/sched/act_ctinfo.c:				ipv4_change_dsfield(ip_hdr(skb),
./net/sched/act_nat.c:	iph = ip_hdr(skb);
./net/sched/act_nat.c:		iph = ip_hdr(skb);
./net/sched/act_ct.c:	iph = ip_hdr(skb);

... 중간 생략 ...

$

아래 Web docs에 아주 자세한 설명과 예제가 있다.

How to Use the Linux xargs Command

https://engineer-mole.tistory.com/235#:~:text=w%20%ED%8C%8C%EC%9D%BC%EB%AA%85%20%23%20%ED%98%84%EC%9E%AC%EC%9D%98%20%ED%8C%A8%ED%84%B4,%EB%B3%80%ED%99%98%20%EB%AC%B8%EC%9E%90%EB%A1%9C%20%EB%B3%80%ED%99%98%ED%95%9C%EB%8B%A4.

Mac, Ubuntu, CentOS에서 Terminal을 사용하다보면, 알록달록 Color가 들어간 Text를 보게 된다.

이렇게 색이 들어간 글자를 만들려면, ANSI escape code라는 표준 기술을 활용해야 한다.

ANSI escape code에 관한 자세한 내용은 이 글의 끝 부분에 있는 Reference Web Docs를 보길~~~

간단하게 터미널의 글자에 색을 넣는 방법만 보면 아래와 같다.

ANSI escape code 확인하는 C source code

각 ANSI code가 어떤 color, font, effect를 보여주는지 확인하고 싶다면, 아래와 같이 짧게 코드를 작성해서 돌려보면 바로 감(느낌)을 찾을 수 있다.

##
## File name:  main.c
##

#include <stdio.h>

int main(void)
{
  int i, j, n;

  for (i = 0; i < 11; i++) {
    for (j = 0; j < 10; j++) {
      n = 10*i + j;
      if (n > 108) break;
      printf("\033[%dm %3d\033[m", n, n);
    }
    printf("\n");
  }
  return 0;
}

위 C source code를 작성하고, 아래와 같이 gcc 명령으로 compile하고 실행해보면, 각 ANSI code의 숫자가 어떤 색을 표현하는지 알 수 있다.

ANSI escape code 확인하는 Python source code

각 ANSI code가 어떤 color, font, effect를 보여주는지 확인하고 싶다면, 아래와 같이 짧게 코드를 작성해서 돌려보면 바로 감(느낌)을 찾을 수 있다.

##
## File name:  main.py
##

import sys
for i in range(0, 16):
    for j in range(0, 16):
        code = str(i * 16 + j)
        sys.stdout.write(u"\u001b[38;5;" + code + "m " + code.ljust(4))
    print u"\u001b[0m"

위 Python source code를 작성하고, 아래와 같이 실행해보면, 각 ANSI code의 숫자가 어떤 색을 표현하는지 알 수 있다.

import sys
for i in range(0, 16):
    for j in range(0, 16):
        code = str(i * 16 + j)
        sys.stdout.write(u"\u001b[48;5;" + code + "m " + code.ljust(4))
    print u"\u001b[0m"

ANSI escape code의 역사, 표준 정보, Example 등 자세한 내용은 아래 Reference Web Docs를 참고하길 ~~~

Reference

※ 아래 Web Docs는 CLI 만들기에 필요한 다양한 Trick과 Tip이 있다.

※ CLI에 Progress Bar, Processing Status, Percentile 등 효과를 넣고 싶다면 아래 Web Docs를 참고할 것 !!!