▼ Vår 2023: IS-105
▼ Oppgaver
▼ Seminar
På denne siden:
1  Plan for seminaret
2  Docker
3  Linux oppsett
4  Profilering i Go
5  Begreper
6  Referanser

Seminar II: Docker, Linux distribusjon, Go profilering

Forkunnskapskrav: grunnleggende systemadministrasjon fra CLI, grunnleggende Git og Github, Go moduler, go build, go test og grunnleggende programmering i Go (forstå package, import, func main() og noen funksjoner fra pakker fmt, os, io, log, bufio, math, bytes, strings, strconv).

Dette seminaret dekker læringsmål 2, 3, 4, 6 og 7 (om muligheter for virksomheter).

Aktivitetene på seminaret II er:

1 Plan for seminaret

Plan for seminar I
Dato Tid Aktivitet Godkjenningskrav
06.03 (aud B1 018) 8:15 - 8:30 Introduksjon og registrering.
06.03 8:30 - 9:00 Vi danner en adskilt gruppe for de som har utfordringer med installasjon og konfigurasjon av programvaren på sin platform. De som har fått sin datamaskin konfigurert, oppfordres til å bidra til at andre får det gjort. Temaene for dette seminaret blir Docker, Linux konfigurasjon og Profilering. Vi deler oss ikke inn etter temaene denne gangen, men temaene bygger på hverandre og derfor vil godkjennes i den ovenfor spesifiserte rekkefølgen.
06.03 9:15 - 9:30 Presentasjon av konfigurasjon av Linux image for Docker.
06.03 9:30 - 10:00 Linux image for Docker (oppgavesett #1) Docker startet på platformen. Kontainer startet basert på ubuntu:latest. CLI startet inn i kontainer. Liste ut og forklare mappestruktur i root-mappen (/)
06.03 10:15 - 11:00 Oppsett av Linux (oppgavesett #2)
06.03 11:15 - 12:00 Fortsetter med Oppsett av Linux (oppgavesett #2) sudo installert og konfigurert og brukerkonto lagt til. Generert en ny image med endringene i basis image.
10.03 (aud B1 007) 8:15 - 8:30 Presentasjon Go profilering
10.03 8:30 - 9:00 Profilering i Go (oppgavesett #3)
10.03 09:15 - 10:00 Profilering i Go (oppgavesett #3) Kan utvikle i kontainer og pushe til Github. Generert 9 profiler. Kan vise frem profiler i nettleser på vertsmaskinen.
10.03 10:15 - 12:00 Godkjenning

2 Docker

Docker er et verktøy som gir mulighet til å utvikle programmer i et lokalt miljø (på egen datamaskin) og distribuere løsninger i sin helhet til andre miljøer, for eksempel, en nettsky. Veldig simplifisert, er Docker et program som gir mulighet til å simulere distribusjoner av forskjellige operativssystemer. Tanken er at en utvikler kan velge en image fra en sentral repository (kalles for Docker Hub) og utvikle sin applikasjon basert på denne imagen. Det er vanlig å velge en basis image, som inneholder operativsystemprogrammer og eventuelt noen spesifikke programmer, og så bygge sine egne imager basert på den.

Når imagen er valgt, kan utvikleren starte en kontainer hvor image kan utføre og kommunisere med vertssystemet. Vertssystemet er da den platformen som du opprinnelig har installert på din maskinvare (de fleste av oss bruker enten Windows eller macOS platformer). Navnet kontainer symboliser et abstrakt isolert (og til viss grad standardisert) element, allokert på vertsmaskinen, som da sørger for tilgang til maskinvaren. Kontainer kan også "transporteres" (overføres) fra en fysisk enhet (vertsmaskinen) til en annen (f. eks., en virtuell server i nettsky).

Grunnleggende arbeidsflyt med Docker

Figur 1. Grunnleggende arbeidsflyt med Docker.

Man kan bruke Docker fra kommandolinje, men Docker har også en grafisk grensesnitt, som kalles Dashboard (følger med i installasjonspakken). I Dashboard kan man se alle imager, som er nedlastet lokalt på vertsmaskinen (et lokalt register, til motsetning av et eksternt register, som Docker Hub) og sårbarhetene i forhold til sikkerhet (en. vulnerabilities) på pakkenivå. Man kan også se alle kontainere som utfører på vertsmaskinen. I Dashboard kan man også konfigurere hvor mye ressurser det virtuelle miljøet kan maksimalt bruke av vertsmaskinens ressurser (CPU, RAM og disk).

For å laste ned en image og starte en kontainer basert på denne imagen, kan følgende kommandoer brukes fra CLI på vertsmaskinen:

Etter at disse kommandoene er utført, skal kontainerens CLI blokkere vertsmaskinens CLI. Åpne en annen CLI på vertsmaskinen, slik at det er mulig å jobbe i begge to.

Oppgaver for Godkjenning

Docker ressurser:

3 Linux oppsett

Virtualiseringsprogramvaren (som Docker) vil gi oss en læringsplatform for å lære om operativsystemer. En student kan installere virtualiseringsprogramvaren på sin platform og bruke denne programvaren for å utforske Unix/Linux-type operativsystemer og deres distribusjoner. Slike operativsystemer har en utstrakt bruk i nettsky konfigurasjoner og i utvikling av distribuerte applikasjoner (per i dag er tilnærmet alle brukbare applikasjoner i denne kategorien).

I dette seminaret skal vi fokusere på en spesifikk distribusjon av Linux, - Ubuntu (les mer i Wikipedia artikkelen om https://en.wikipedia.org/wiki/Ubuntu). Vi skal jobbe med Docker image ubuntu:latest, som skal være av versjon 22.04, som har kodenavnet Jammy Jellyfish (Releases - Ubuntu Wiki, 2022). Det vil være tre hovedområder som dere skal utførske, - (1) bruken av pakkeadministrasjonssystemer, (2) konfigurasjon av en annen brukerkonto enn root sin og (3) automatiske oppdateringer (og sikkerhetsoppdateringer). I tillegg skal dere se på en interessant sak. Dere skal også aksessere et program, som utføres i kontainer fra nettleseren til vertsmaskinen i forbindelse med Go profilering.

Det forventes at dere kan bruke CLI kommandoer og tekstredigering direkte i CLI (nano, vim, emacs).

Pakkeadministrasjon

Kommandoer for pakkeadministrasjon varierer fra distribusjon til distribusjon. Det finnes to store distribusjonsgrupper, - Centos/Red Hat og Debian/Ubuntu. Vi vil utforske CLI programmet apt-get for Debian/Ubuntu, siden vår image ubuntu:latest har det installert.

Etter at dere har utført docker run og docker exec vil CLI i kontainer ha en prompt som dette:


      root@c6f804d8ca1:~#

                      root - brukernavn
                      c6f804d8ca1 - kontainer ID
                      ~ - den gjeldende mappen (her /root)

root er den eneste brukerkontoen på et nylig installert system og har alle administrative rettigheter.

Kontainer ID kan vises med CLI (vertsmaskin) kommando docker container ls. Dere har allerede brukt CLI i kontainer for å liste ut FSH-strukturen i oppgaven om Docker.

ubuntu:latest er en grunnleggende image, så det er en del viktig systemprogramvare som ikke er med i den. I vårt virtualiseringsmiljø, som er Docker, så kan vi anta at vi har tilgang til den samme maskinvaren som vår vertsmaskin har. Hvis man skulle installert et operativsystem fra bunnen av og direkte på maskinvaren, så skulle man trenge å gjøre mer konfigurasjon av, blant annet, tastatur oppsett, nettverksgrensesnitt, skjerm/skjermkort og eventuelt vindu-systemet for det grafiske brukergrensesnittet. Vi skal ikke starte GUI-baserte programmer i Docker kontainer og vil kun konfigurere den som en "backend"-løsning og et utviklingsmiljø (med git og go).

Først installer de nyeste pakkene for Linux distribusjonen og bruk eksisterende kommandoer for å ta vekk det som det ikke er et umiddelbart behov for. Dette må gjøres fra kontoen til root-brukeren (siden noen programmer må installeres for å kunne konfigurere nye brukerkontoer). Tegnet $ brukes videre i eksemplene for å betegne hele prompten.


      $ apt-get update
      $ apt-get dist-upgrade
      $ apt-get autoremove
      $ apt-get autoclean

For å kunne konfigurere en brukerkonto i tillegg til root-kontoen, må vi installere programmet sudo ("superuser do"), som vil betraktelig øke sikkerheten i vårt system. Man kan gjøre følgende ved hjelp av sudo:

I seminaret kommer vi kun til å berører en liten del av konfigurasjonsmulighetene som sudo gir.

Installer sudo i kontainer:


      $ apt-get install -y sudo
                          
                          apt-get - programmet for pakkeadministrasjon
                          install - et argument for apt-get
                          -y - automatisk "ja" til spørsmål på STDIN
                          sudo - pakke som skal installeres

Det er også nødvendig å installere en teksteditor i kontaineren. Her er et eksempel for å installere nano (du kan bare bytte ut nano med vim eller emacs, eller installere alle 3 hvis du ønsker):


      $ apt-get install -y nano

Da er systemet klar for å sette opp en brukerkonto.

En (viktig) digresjon om endringene i kontainere

Alle operasjoner til nå har foregått i kontainer minubuntu, forutsatt at kommandoen for å starte kontainer var docker run --name minubuntu -d -i -p 8080:8080 ubuntu. Det er viktig å huske på at alle endringene i kontainer vil gå tapt, hvis vi avslutter kontainer med docker container stop minubuntu og fjerner den med docker container rm minubuntu. Vi vil også miste alle endringene, hvis vi avslutter Docker Desktop på vår maskin uten å stoppe og fjerne kontainer enten fra CLI eller fra Dashboard.

For å beholde endringene vi gjør i en kontainer permanent, kan man lage en ny image med kommandoen docker commit minubuntu minubuntu:version1. Man kan velge et navn og en tag for den nye imagen. Husk at minubuntu er navn til en kontainer, mens minubuntu:version1 er navn til den nye imagen. Den nye imagen kan brukes for å starte en ny kontainer med et fritt valgt navn. Man kan starte flere kontainere fra den samme imagen og i det tilfelle må man navngi kontainere unikt.

Imager kan ta stor plass på din lokale lagringsenhet, så det kan være en god praksis å slette de imagene, som man ikke har behov for med jevne mellomrom. Kommandoen for å slette en image permanent er docker rmi IMAGENAVN, hvor imagenavn består av et navn og en tag, for eksempel minubuntu:version1. Imagen kan kun slettes hvis alle kontainere som ble startet fra imagen er fjernet med docker container rm KONTAINERNAVN, hvor kontainer navn er det navnet som ble brukt i docker run --name flagget.

Oppsett av en brukerkonto

Som tidligere nevnt, er Unix og Linux designet som multibrukersystemer. Derfor har grunnleggende distribusjoner spesifikke verktøy for å sette opp og administrere nye brukerkontoer. Prinsippet om kontoer er ikke annerledes fra det som brukes i webtjenester, hvor brukeren blir bedt om å registrere seg. Ved hjelp av brukerkontoer kan informasjon for hver bruker holdes adskilt fra informasjon til andre brukere (personalisering). Forskjell i operativsystemer er at brukere kan ikke registrere seg selv, dvs. skape en konto. Det må gjøres av en administrator med en root-konto.

Verktøyet vi skal bruke for å skape brukerkonto er sudo. Når vi installerte verktøyet, lagret insallasjonsprogrammet også en del konfigurasjon på vårt filsystem. Man kan redigere konfigurasjon med kommando:


      $ sudo visudo

Grunnen til at konfigurasjon endres gjennom et spesifikt kommando og ikke direkte redigering av en konfigurasjonsfil (som i mange andre tilfeller for en distribusjon av Linux operativsystemet) er sikkerhet.

I sudo konfigurasjonsfilen finnes det følgende linjer:


      # User privilege specification
      root    ALL=(ALL:ALL) ALL
      # Allow members of group sudo to execute any command
      %sudo   ALL=(ALL:ALL) ALL

                         % indikerer at det er en gruppe
                         Første ALL er tilgang til brukerkontoer
                         Andre  ALL er verter (en. hosts)
                         Tredje ALL er brukerkonto som utfører kommando
                         Fjerde ALL er tilgang til kommandoer

Som vi kan se, i standardkonfigurasjonen, alle som er medlemmer i gruppen sudo har de samme privilegiene som brukeren root. Vi vil i denne omgangen ikke endre standardkonfigurasjonen. Men vi skal legge til vår nye bruker i gruppen sudo.

Det finnes (minst) to programmer for å administrere brukere i Ubuntu. adduser finnes hovedsakelig i Debian distribusjoner (Ubuntu er en Debian distribusjon). useradd finnes i de fleste Linux distribusjoner og er et mer "lavt-nivå" verktøy for administrere brukere. Vi lager vår bruker (med navn BRUKERNAVN, som du erstatter med det brukernavnet du velger selv) med useradd. Siden vi fortsatt har kun root-kontoen på systemet, gjør vi dette i terminalen til root:


      $ useradd -G sudo -m -d /home/BRUKERNAVN -s /bin/bash BRUKERNAVN

                    -G - legge til den nyskapte brukeren i gruppen sudo
                    -m - står for "make home directory"
                    -d - spesifiserer hjemmemappen (bør ligge i /home)
                    -s - står or "shell" som settes til /bin/bash

Vi spesifiserte ikke passord i flagget til useradd. Vi kunne brukt -p flagget for å spesifisere passord, men da måtte vi ha skrevet inn passordet i klartekst på kommandolinje. Det anbefales ikke at man gjør. Derfor lager vi passord med et annet kommando (skriv inn det passordet du ønsker to ganger):


      $ passwd BRUKERNAVN

Dette passordet skal du bruke når du skal gjøre administrative oppgaver i din kontainer, som, for eksempel, å installere nye programmer ved å bruke sudo foran administrative kommandoer. Når du har spesifisert passordet en gang, kan du gjøre root-oppgaver i 5 minutter (standardinnstilling som kan endres) uten å oppgi passord på nytt. Hvis du i denne perioden utfører kommando sudo -k, så må passordet oppgis på nytt. Dette var en viktig sak før, når man jobbet i større datalaber og forlot ofte terminalen åpen. Hvis da perioden for å jobbe uten passord hadde ikke gått ut, kunne noen andre utføre administrative oppgaver fra ens brukerkonto.

Nå kan du logge inn i din nye konto ved å skrive denne kommandoen fra root-terminalen:


      $ su - BRUKERNAVN

Du trenger ikke å oppgi passord, fordi at du utfører denne kommandoen som root.

Du kan også gå ut av din kontainer ved å skrive exit to ganger (hvis du var i terminalen til den nye brukerkontoen). Da skal du se terminalen til vertsmaskinen (du kan identifisere den basert på prompten).

Nå kan du også lage en ny image (commit) med kommandoen (i CLI for vertsmaskinen):


      $ docker commit minubuntu minubuntu:versionN

                          minubuntu - kontainernavn du nettopp logget deg ut av
                          minubuntu:versionN - ny image med navn minubuntu og tag versionN
                          N - erstatte N med den versjonen som er relevant

Se med kommandoen docker images om en ny image er blitt laget. Så kan du gjøre følgende for å stoppe den kjørende kontaineren, slette den, starte en ny kontainer basert på den nye imagen og logge deg inn med din nye brukerkonto:


      $ docker container stop minubuntu
      $ docker rm minubuntu
      $ docker run --name minubuntu -d -i -p 8080:8080 minubuntu:versionN
      $ docker exec -it --user BRUKERNAVN minubuntu /bin/bash

Om automatiske oppdateringer

En viktig avgjørelse alltid må taes angående automatiske eller ikke automatiske oppdateringer. Automatiske oppdatering i de fleste tilfellene trenger restart av systemet. Det er ikke en god løsning hvis systemet tilbyr tjenester til mange brukere, som er avhengige av at det funksjonerer. Oppdateringer av et program kan også i noen tilfeller bryte ned andre programmer. Selv om avhengighetsadministrasjon blir stadig bedre, feil fortsatt oppstår. En god sikkerhetsstrategi er å planlegge systemoppdateringer nøye og gjøre disse så sjeldent som mulig ved annonserte tidsperioder eller i perioder med lite trafikk.

Vi ser her på et eksempel av hvordan det er mulig å få informasjon om systemoppdateringer og samtidig deaktivere automatiske oppdateringer. Det er ingen garanti at dette verktøyet vil fange opp alle sårbarheter, så man bør kombinere det med andre manuelle (og eventuelt automatiske) verktøy. Husk oversikt over sårbarheter i Docker Dashboard.

I Ubuntu kan man installere en pakke, som lar systemadministratoren å administrere "uovervåket oppdatering" (en. unattended upgrades).


      $ sudo apt-get install -y unattended-upgrades

Det er mulig å endre konfigurasjonsfilen /etc/apt/apt.conf.d/20auto-upgrades slik at automatisk oppdatering vil ikke skje ved systemstart. Filen inneholder kun to linjer og i den andre linjen endrer man "1" til "0", som da vil si at Unattended-Upgrade vil ikke gjennomføres. Innholdet i filen skal da være:


      APT::Periodic::Update-Package-Lists "1";
      APT::Periodic::Unattended-Upgrade "0";

For å sjekke om det finnes noen sikkerhetsrelaterte oppdateringer, uten å se ikke-sikkerhetsrelaterte oppdateringer bruk følgende kommando:


      $ sudo unattended-upgrade --dry-run -d

For å installere alle tilgjengelige sikkerhets-relaterte oppdateringer, kan man utføre samme kommando uten flagget --dry-run:


      $ sudo unattended-upgrade -d

En interessant sak

Det er en kjent sak at det finnes databaser av hash-verdier til passord, slik at kontoene med slike passord kan misbrukes. Vi skal se på et eksempel på hvordan man kan sjekke om et passord er kompromitert (en. pawned) eller ikke. Dette gjelder en spesikk krypteringsalgoritme SHA-1, som er erklært som usikker.

Velg en egnet mappe i din hjemmemappestrukturen og lag en fil med navn pawned.sh (kan bruke nano). Legg inn følgende innhold i filen (vi går gjennom detaljene på seminaret):


      #!/bin/bash
      candidate_password=$1
      echo "Candidate passwordd: $candidate_password"

      full_hash=$(echo -n $candidate_password | sha1sum | awk '{print substr($1, 0, 32)}')
      prefix=$(echo $full_hash | awk '{print substr($1, 0, 5)}')
      suffix=$(echo $full_hash | awk '{print substr($1, 6, 26)}')

      if curl https://api.pwnedpasswords.com/range/$prefix | grep -i $suffix;
          then  echo "Candidate password is compromised";
          else echo "Candidate password is OK for use";
      fi

Dette er en såkalt shell script, som er et eget programmeringsspråk. Den er spesielt egnet til å binde systemprogrammene sammen for å implementere spesifikke brukertilfeller.

Etter redigering med en teksteditor har filen mest sannsynlig (avhenger av umask) tilgangsrettighetene -rw-rw-r--. En slik fil kan ikke utføres på kommandolinje. Bruk 


      $ chmod 764 pawned.sh
for å gjøre filen utførbar for din brukerkonto.

Så kan du prøve 


      $ ./pawned.sh student
og trekke dine egne konklusjoner.

Oppgaver for Godkjenning

4 Profilering i Go

Go har mange verktøy i verktøyboksen, som kan hjelpe en utvikler til å ha bedre kontroll på programmene som utvikleren skriver. Vi har sett go test og nå skal bli kjent med et nytt verktøy, - pprof.

Utviklerverktøy kan generelt klassifiseres i følgende klasser:

Vi skal se på benchmarking og debugging senere, men i dette seminarer introduseres det profilering. Kort sagt, er profilering en måten å stoppe programmet etter en spesifisert tidsperiode og lagre et "avtrykk" som programmet gjør på CPU eller minne. Hvis tidsperioden er valgt optimalt, kan man identifisere unormal bruk av enten prosessor eller primært minne. Ofte skyldes en slik unormal bruk av ressurser måten utvikleren har brukt programmeringsspråket på. Et ofte brukt eksempel er relatert til bruken av buffer. Hvis det er lite plass til mellomlagring, må vanligvis prosessoren arbeide mer. Dette illustrerer også den mest kritiske "trade-off", som en utvikler bør være oppmerksom på, - "trade-off" mellom belastning av prosessor og belastning av minne.

Dere finner all nødvendig kode i repositorien til uia-worker pprof. Denne gangen skal dere gjøre forking av denne repositorien og så jobbe videre på deres egen versjon (videre omtalt som DIN-FORKEDE-REPOSITORY). Dere skal klone den forkede versjonen i deres kontainer og jobbe videre på den. Dere må kunne pushe profilfilene (de skal være SVG-filer) til deres repository.

For å kunne gjennomføre oppgaven, må følgende installeres og konfigureres (fra din brukerkonto, ikke fra root-kontoen):

Teste at Github autentiseringen funksjonerer fra CLI i kontaineren: 


          $ git clone DIN-FORKEDE-REPOSITORY
          $ cd pprof
          $ nano README.md
                          legg til en ny linje i README.md og lagre filen

          $ git add README.md
          $ git commit -m "endert README.md"
          $ git push origin main

Nå anbefales det å lage en ny image med docker commit for å ta vare på alle endringene gjort i kontaineren. Stop og slett den gjeldende kontaineren og starte en ny kontainer med den nye imagen før du fortsetter.

Neste oppgave er å generere profiler. I repository pprof er det tre filer, som kan brukes for å utforske profilering (koden er basert på Dave Cheney sin video (Gopher Academy, 2019)):

For at det kompilerte (og lenkede) Go programmet skal kunne generere informasjon om bruken av CPU eller primært minne, må det skrives instruksjoner i kildekoden. Vi skal utforske 3 typer av profilering og instruksjoner for hver av disse er i alle wordcount-filene. Denne koden finnes i alle tre filene:

Det er kun en linje av gangen som skal være aktiv. De to andre skal kommenteres ut. Den første linjen skal generere en fil med navn cpu.pprof. De to andre skal generere en fil med navn mem.pprof. Den første gjelder profilen for CPU, dvs. hvor mye prosessortid brukes det av de forskjellige funksjonene i programmet. De to siste gjelder profilen for RAM (primært minne). Forskjellen på de to er at den siste vil vise alle minneallokeringene, som de forskjellige funksjonene i programmet gjennomfører (det sørger argumentet profile.MemProfileRate(1) for; standardverdien er 4096 bytes, og man kan endre verdien hvis man ikke får nok informasjon fra den genererte profilen).

Det skal genereres tre profiler for hver fil, dvs. 9 profiler tilsammen. For eksempel, med CPU profilering aktivert i wordcount01.go, så vil det bli generert en fil med navn profile001.svg (vi vil bruke svg alternativet her; pprof har også andre alternativer som pdf, for eksempel). Hvis du forsetter med filen wordcount02.go, så vil det blir generert en fil med navn profile002.svg osv. Skriv i README.md filen hvilken profilfil som gjelder for hvilken kombinasjon av wordcount-fil og profiltype (som spesifisert i kildekoden).

Vi bruker go tool pprof FILNAVN for å kunne lage SVG bilder av profilene. Denne kommandoen skal føre til en egen prompt (pprof). I denne prompten kan man finne informasjon om alle kommandoene ved å skrive help og man kan gå ut av denne prompten med kommando exit.

For å kunne lage profiler må du gjøre følgende:

Du skal ende opp med de 9 filene profile001.svg ... profile009.svg. Når du har gjort dette så skal du pushe filene opp til DIN-FORKEDE-REPOSITORY. Finn selv en løsning for å ikke pushe opp de binære filene (tips: husk metoden fra seminar I curl --output .gitignore --url https://raw.githubusercontent.com/uia-worker/is105test/main/.gitignore ; dette vil kreve insallasjon av curl pakken, som du kjenner fra før).

For å sammenligne med operativsystemets program wc må du utføre følgende kommandoer (noter resultatene):


      $ time wc -w STORFIL
      $ time ./wordcount01 STORFIL
      $ time ./wordcount02 STORFIL
      $ time ./wordcount03 STORFIL

Koden for profilgenerering inngår også i tidsmålingene, så du må også gjøre målinger med all koden for profilering kommentert ut.

Nå anbefales det igjen å lage en ny image med docker commit for å ta vare på alle endringene gjort i kontaineren. Stop og slett den gjeldende kontaineren og starte en ny kontainer med den nye imagen før du fortsetter.

pprof har også en interessant funksjonalitet, som gir mulighet til å analysere profilene meget detaljert i et brukergrensesnitt. Men vi kan vel ikke utføre programmer med GUI i vår kontainer? Ikke slik som den er konfigurert nå, og det er heller ikke ingen vanlig sak man gjør, siden kontainere brukes mest for backend-utvikling. Men vi kan alltid starte en server i kontainer og bruke nettleseren på vertsmaskinen som GUI. Det oppnår vi med flagget -p 8080:8080 i kommandoen docker run. Dette flagget gjør at den prosessen som utfører på porten 8080 i kontaineren, blir publisert ut til vertsmaskinen på port 8080 (trenger ikke å være det samme).

I kontaineren (og i den mappen hvor profilfilen ligger) gjør følgende:


      $ go tool pprof -http=0.0.0.0:8080 cpu.pprof

             Det vil generere en ca. slik output:
                 Serving web UI on http://0.0.0.8080
                 Couldn't find a suitable web browser!
                 ...

Det er klart at programmet ikke kan finne en nettleser i kontaineren, siden det ikke finnes noen. Men serveren er blitt startet i kontaineren og vi kan koble til denne serveren ved å skrive url http://localhost:8080 i nettleseren på vår vertsmaskin. Så er det bare å grave i alle dataene! Analyse av dataene skal ikke være en del av kravene for dette seminaret, men vi skal bruke profilene videre i undervisnigen og temaet kan også være relevant for eksamen. Relevant lesestoff ligger i Google sin pprof repository (google, 2022).

Kommandoen, som startet webserveren, blokkerer kommandovinduet og når du er ferdig med utforskning av profilen, kan du avslutte serveren i kontaineren med Ctrl-C tastkombinasjonen.

Oppgaver for Godkjenning

5 Begreper

Noen utvalgte begreper. Det anbefales at studentene fører sin egen begrepsliste.

nettsky
IT samling av datatjenester som ytes over Internett og som samvirker med andre datatjenester, f.eks. fjernlagring, backup av data og fjernbruk av dataprogrammer ; cloud computing
vertsmaksin
Datamaskinen som er startet opp med et spesifikt operativsystem og klar til å utføre andre programmer, for eksempel, programmer som simulerer andre operativsystemer.

6 Referanser