R Academy · Oppitunti

HTTP-pyyntöjen tekeminen httr2-paketilla

Lähettäkää GET- ja POST-pyyntöjä, käsitelkää otsakkeita ja käsitelkää vastaukset.

Oppitunti 2/413 vaihetta

HTTP-pyyntöjen tekeminen httr2-paketilla on ilmainen R Academy-oppitunti CoddyKitissä. Tämä on oppitunti 2/4. Voit lukea tästä oppimispolusta kokonaan mitkä tahansa 3 oppituntia ilmaiseksi — sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä käytännön harjoittelun sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Oppitunti kuuluu R Academy-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. R Academy-kurssilla on yhteensä 4 oppituntia.

httr2:n esittely

httr2 on nykyaikainen R-paketti HTTP-pyyntöihin, ja se korvaa paketin httr. Se käyttää putkiin perustuvaa rakentajamallia: aloittakaa komennolla request(url), lisätkää muokkaimet ja suorittakaa pyyntö komennolla req_perform().

library(httr2)

# Basic GET request pattern:
# request(url)     -> create request object
# |> req_*()       -> modify request
# |> req_perform() -> send request
# |> resp_*()      -> extract from response

# Minimal example (requires internet):
# resp <- request('https://httpbin.org/get') |>
#   req_perform()
# resp_status(resp)     # 200
# resp_body_json(resp)  # parsed JSON body

cat('httr2 follows: build -> perform -> extract')

request() ja req_perform()

request(url) luo pyyntöolion. req_perform() suorittaa pyynnön ja palauttaa vastausolion. Vastausta voi tämän jälkeen tutkia resp_*-funktioilla.

library(httr2)

# Build and send a GET request
# resp <- request('https://httpbin.org/get') |>
#   req_perform()

# Inspect response
# resp_status(resp)          # 200
# resp_status_desc(resp)     # 'OK'
# resp_headers(resp)         # list of headers
# resp_header(resp, 'content-type')  # single header
# resp_body_string(resp)     # raw body as string
# resp_body_json(resp)       # parsed JSON
# resp_body_raw(resp)        # raw bytes

cat('Response hierarchy:')
cat('status -> headers -> body')

req_headers(): mukautetut otsakkeet

req_headers() lisää HTTP-otsakkeita tai korvaa niitä. Sitä käytetään todennustunnisteisiin, sisällön tyypin määrittämiseen, API-version otsakkeisiin ja mukautettuihin pyynnön metatietoihin.

library(httr2)

# Add custom headers
# resp <- request('https://api.example.com/data') |>
#   req_headers(
#     'Authorization' = 'Bearer my_token',
#     'X-API-Version' = '2',
#     'Accept'        = 'application/json'
#   ) |>
#   req_perform()

# Common headers:
# 'Content-Type' = 'application/json' for POST with JSON body
# 'Accept'       = 'application/json' to request JSON response
# 'User-Agent'   = 'MyApp/1.0' for polite identification
# 'X-API-Key'    = key  for key-based auth

cat('req_headers() sets HTTP request headers')

req_url_query(): kyselyparametrit

req_url_query() lisää kyselyparametrit URL-osoitteeseen turvallisesti ja koodaa erikoismerkit. Se on selkeämpi ratkaisu kuin merkkijonojen manuaalinen yhdistäminen paste0()-funktiolla.

library(httr2)

# Add query parameters
# resp <- request('https://api.example.com/search') |>
#   req_url_query(
#     q      = 'R programming',
#     page   = 1,
#     size   = 20,
#     sort   = 'relevance'
#   ) |>
#   req_perform()
# Resulting URL:
# https://api.example.com/search?q=R+programming&page=1&size=20&sort=relevance

# Inspect the URL without performing:
req <- request('https://api.example.com/search') |>
  req_url_query(q = 'hello world', page = 2)
req$url
# 'https://api.example.com/search?q=hello+world&page=2'

POST-pyynnöt req_body_json()-funktiolla

Lähettäkää JSON-dataa POST-pyynnössä komennolla req_body_json(). Se asettaa automaattisesti otsakkeen Content-Type: application/json ja sarjallistaa R-listan JSONiksi.

library(httr2)

# POST request with JSON body
# resp <- request('https://api.example.com/users') |>
#   req_method('POST') |>
#   req_body_json(list(
#     name  = 'Alice',
#     email = 'alice@example.com',
#     role  = 'admin'
#   )) |>
#   req_perform()

# resp_status(resp)     # 201 Created (if success)
# resp_body_json(resp)  # returned user object

# Other body methods:
# req_body_form(...)  -> application/x-www-form-urlencoded
# req_body_raw(bytes) -> raw bytes
# req_body_file(path) -> file upload
cat('req_body_json() handles Content-Type automatically')

resp_body_json(): vastauksen jäsentäminen

resp_body_json() jäsentää vastauksen rungon JSON-datana R-listaksi. Asetuksella simplifyVector=TRUE (oletus) JSON-taulukot muunnetaan automaattisesti R-vektoreiksi ja objektit nimetyiksi listoiksi.

library(httr2)
library(jsonlite)

# Simulated API response handling
# resp <- request('https://api.github.com/users/hadley') |>
#   req_perform()
# user <- resp_body_json(resp)
# user$name    # 'Hadley Wickham'
# user$public_repos  # number of repos
# user$followers     # follower count

# For arrays (simplifyVector=TRUE converts to data frame):
# resp <- request('https://api.github.com/users/hadley/repos') |>
#   req_perform()
# repos <- resp_body_json(resp, simplifyVector = TRUE)
# repos$name  # vector of repo names

cat('resp_body_json() with simplifyVector=TRUE -> data frame')

resp_status() ja virheenkäsittely

resp_check_status() aiheuttaa automaattisesti virheen 4xx- ja 5xx-vastauksille. Ilman sitä httr2 ei ilmoita virheestä huonojen tilakoodien kohdalla — tilakoodi on tarkistettava erikseen tai kutsuttava resp_check_status()-funktiota.

library(httr2)

# Pattern: check status after perform
# resp <- request('https://api.example.com/data') |>
#   req_perform() |>
#   resp_check_status()  # errors on 4xx/5xx

# Manual status checks:
# status <- resp_status(resp)
# if (status == 200) { ... }
# if (status == 404) { stop('Not found') }
# if (status == 401) { stop('Unauthorized') }
# if (status == 429) { Sys.sleep(60); retry() }

# HTTP status codes:
# 200 OK, 201 Created, 204 No Content
# 400 Bad Request, 401 Unauthorized, 403 Forbidden
# 404 Not Found, 429 Rate Limited
# 500 Server Error, 503 Service Unavailable
cat('Always check response status codes')

req_retry(): automaattiset uudelleenyritykset

req_retry() yrittää epäonnistuneita pyyntöjä automaattisesti uudelleen. Määrittäkää max_tries ja halutessanne is_transient (funktio, joka tunnistaa uudelleenyritykseen sopivat virheet, kuten 429 tai 503). Tämä on välttämätöntä luotettaville API-asiakkaille.

library(httr2)

# Automatic retry with exponential backoff
# resp <- request('https://api.example.com/data') |>
#   req_retry(
#     max_tries = 3,
#     is_transient = function(resp) {
#       resp_status(resp) %in% c(429, 500, 503)
#     },
#     backoff = ~ 2^.x  # exponential: 2, 4, 8 seconds
#   ) |>
#   req_perform()

# Default retry behavior:
# - Retries on 429 Too Many Requests automatically
# - Uses Retry-After header if present
# - max_tries = 1 by default (no retry)

# Simple retry:
# req_retry(max_tries = 3)  # retry up to 3 times total
cat('req_retry() adds resilience to API calls')

req_throttle(): nopeusrajoitus

req_throttle(rate) varmistaa, ettette ylitä pyyntöjen enimmäisnopeutta. Antakaa arvoksi rate = n/period (esimerkiksi 10 pyyntöä minuutissa). httr2 odottaa pyyntöjen välillä automaattisesti tarpeen mukaan.

library(httr2)

# Throttle to at most 10 requests per minute
# urls <- paste0('https://api.example.com/items/', 1:50)
# resps <- lapply(urls, function(url) {
#   request(url) |>
#     req_throttle(rate = 10 / 60) |>  # 10/min
#     req_perform()
# })

# Alternative: use req_perform_parallel() for parallel
# with throttle built in:
# reqs <- lapply(urls, \(u) request(u))
# resps <- req_perform_parallel(
#   reqs,
#   on_error = 'continue',  # skip failures
#   progress = TRUE
# )

cat('req_throttle(rate = 10/60) = 10 req/min')

Todennuksen apufunktiot

httr2 tarjoaa valmiit todennuksen apufunktiot: req_auth_basic(user, pass) Basic-todennukseen, req_auth_bearer_token(token) Bearer-tunnisteisiin ja req_oauth_*() OAuth- työnkulkuihin.

library(httr2)

# Bearer token (most common for modern APIs)
# resp <- request('https://api.example.com/data') |>
#   req_auth_bearer_token('my_api_token_here') |>
#   req_perform()

# Basic authentication
# resp <- request('https://api.example.com/data') |>
#   req_auth_basic('username', 'password') |>
#   req_perform()

# Store tokens securely in environment variables
# token <- Sys.getenv('MY_API_TOKEN')
# resp <- request('https://api.example.com') |>
#   req_auth_bearer_token(token) |>
#   req_perform()

cat('Never hardcode tokens in scripts!')
cat('Use Sys.getenv() or the keyring package')

Kuiva-ajo req_dry_run()-funktiolla

req_dry_run() näyttää tarkalleen, millainen pyyntö lähetettäisiin (menetelmä, URL-osoite, otsakkeet ja runko), lähettämättä sitä kuitenkaan. Tämä on tärkeää monimutkaisten pyyntöjen virheenkorjauksessa ennen oikeaan API-rajapintaan yhdistämistä.

library(httr2)

# Inspect the request without sending it
req <- request('https://api.example.com/users') |>
  req_method('POST') |>
  req_headers(
    'X-API-Version' = '2',
    'Accept'        = 'application/json'
  ) |>
  req_auth_bearer_token('my_token') |>
  req_body_json(list(name = 'Alice', role = 'admin')) |>
  req_url_query(notify = 'true')

# Show request details without sending
req_dry_run(req)
# POST /users?notify=true HTTP/1.1
# Host: api.example.com
# Authorization: Bearer my_token
# Content-Type: application/json
# ...

Pikatesti

Testatkaa, miten hyvin ymmärrätte httr2:n pyyntöjen rakentamismallin.

Vastaa interaktiivisessa oppitunnissa

Kertaus: HTTP-pyynnöt httr2:lla

Tärkeimmät asiat: httr2 käyttää putkiin perustuvaa rakentajaa: request(url) |> req_*() |> req_perform(). Lisätkää otsakkeet komennolla req_headers(), kyselyparametrit komennolla req_url_query() ja JSON-runko komennolla req_body_json(). Käyttäkää todennukseen req_auth_bearer_token()-funktiota. Tarkistakaa tila aina komennolla resp_check_status(). Parantakaa vikasietoisuutta komennolla req_retry() ja rajoittakaa nopeutta komennolla req_throttle(). Korjatkaa virheitä komennolla req_dry_run().

library(httr2)

# Complete httr2 request pattern:
# resp <- request('https://api.example.com/endpoint') |>
#   req_headers('Accept' = 'application/json') |>
#   req_url_query(param1 = 'value', page = 1) |>
#   req_auth_bearer_token(Sys.getenv('API_TOKEN')) |>
#   req_retry(max_tries = 3) |>
#   req_throttle(rate = 10/60) |>
#   req_perform() |>
#   resp_check_status()

# Extract data:
# data <- resp_body_json(resp, simplifyVector = TRUE)

cat('build -> authenticate -> perform -> check -> extract')

Aloita maksutta

Opi R tekoälytuutorin avulla — ilmaiseksi

Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.

Kurssit: 43
Oppitunnit: 159

Aloita opiskelu maksutta Näytä koko kurssi

Usein kysytyt kysymykset

Onko oppitunti ”HTTP-pyyntöjen tekeminen httr2-paketilla” ilmainen?

Kyllä — voit lukea täällä verkossa kokonaan ilmaiseksi mitkä tahansa R Academy-oppimispolun 3 oppituntia, myös oppitunnin “HTTP-pyyntöjen tekeminen httr2-paketilla”. Sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä interaktiiviset harjoitukset sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. R Academy-kurssilla on yhteensä 4 oppituntia.

Mitä opin oppitunnilla ”HTTP-pyyntöjen tekeminen httr2-paketilla”?

Lähettäkää GET- ja POST-pyyntöjä, käsitelkää otsakkeita ja käsitelkää vastaukset. Harjoittelet R Academy-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.

Tarvitsenko kokemusta aloittaakseni R Academy-opiskelun?

Aiempi kokemus ei ole tarpeen. CoddyKitin R Academy-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 2/4.

Kuinka kauan ”HTTP-pyyntöjen tekeminen httr2-paketilla”-oppitunnin suorittaminen kestää?

Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.

Voinko kirjoittaa ja suorittaa koodia tällä R Academy-oppitunnilla?

Kyllä. Jokainen R Academy-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.

Kaikki tämän kurssin oppitunnit

JSON-jäsentäminen jsonlite-paketilla
HTTP-pyyntöjen tekeminen httr2-paketilla
REST-rajapintojen käyttäminen R:ssä
Sisäkkäisten JSON-rakenteiden käsittely

← Takaisin: R Academy