ALTO (protocol)

From HandWiki
Application Layer Transport Optimization (ALTO)
International standardRFC 7285
Developed byIETF

Application Layer Transport Optimization (ALTO) is a protocol that allows internet clients to obtain information that compares the network properties of paths to other endpoints. Typically, this would be used to identify the lowest-cost location to access a copy of some sort of content.[1]

The ALTO base protocol is specified in RFC 7285.[2] It requires "ALTO servers" to be deployed in the network with knowledge of network properties, often simply the routing cost to various endpoints.[3] An "ALTO client," typically tied to a user agent attempting to obtain a resource, queries the ALTO server over HTTP to obtain the optimal location from which to retrieve the resource.

History

Starting around 2005, the widespread use of peer-to-peer applications such as BitTorrent was a serious concern to many network operators, as the massive amounts of network traffic caused by these applications had a significant impact on traffic engineering and revenues. Some network operators tried to throttle this traffic.[4]

In May 2008, in an IETF Workshop on Peer-to-Peer Infrastructure, several areas of work were identified:[5]

  1. A standardized interface for the exchange of information between the underlying IP network and an overlay network, such as a peer-to-peer network. The basic idea is, that if the overlay network was aware of the topology and the cost for sending traffic through the underlying IP network, it could optimize decisions with respect to the overlay network's topology (e.g., peer selection) and routing of traffic through the overlay network. The result would be better performance or Quality of Experience in the application while reducing the utilization of the underlying network infrastructure. This work item led to the establishment of the IETF ALTO working group.
  2. Content caches in the network. This has been studied in the IETF DECADE working group. However, no new protocol has been developed and standardized.[6]
  3. A new congestion control mechanism in the transport layer for background traffic, which "yields" to standard TCP. This was worked on in the IETF LEDBAT working group and has been standardized in RFC 6817.[7]
  4. A new DiffServ code point to mark IP packets to have a lower priority than the default "best effort" category has been standardized in RFC 8622.[8]

The IETF ALTO working group was established in November 2008.[9] The first deliverables were the problem statement,[1] the requirements document,[3] the specification of the core ALTO protocol[2] and an ALTO server discovery mechanism.[10] Since then, various extensions have been specified (see below) or are still work in progress (see IETF ALTO Datatracker[11]).

Originally designed to support peer-to-peer file sharing, the concept is broadly applicable to many network problems.[12] However, as of 2021 it has not achieved widespread deployment in the internet. Nevertheless, there have been experiments in Internet service provider (ISP) networks and a deployment to support large data transfers for the Large Hadron Collider at CERN.[13]

Protocol overview

ALTO servers typically operate inside an ISP and collect information about the topology of the ISP network. The means of collecting this information are out of scope for the ALTO design, but typically this would involve participating in the routing protocol's information exchange, accepting policy inputs from network management, and data from various network monitoring systems.

The ALTO server uses this information to provide services to the client.

The first step in retrieving ALTO information is to locate the ALTO server. If the ALTO client is located on the host that is also the endpoint of the data transmissions to be optimized, the ALTO server discovery procedure specified in RFC 7286[10] may be used. In contrast, when the ALTO client is located on a different host (e.g., when a BitTorrent tracker with an embedded ALTO client wants to optimize peer selection on behalf of a peer that might be in a different network domain), the cross-domain server discovery procedure specified in RFC 8686[14] should be used. A client might have the service discovery domain name directly configured, but usually it will obtain the name via DHCP when joining a network. It then composes a DDDS query to that service discovery host for the "ALTO:https" or "ALTO:http" Application Service tag, which in turn returns the URL for any available ALTO Server Information Resource Directories (IRD).

A client would then retrieve the IRD from one of the ALTO servers, which lists the specifics of what services are available, supported parameters, and the locations of those services.

There are four service types in the base protocol:

The Map Service provides a file that lists all the endpoints or PIDs that the server tracks. A "network map" serves as a "table of contents" that the client can use to construct more specific queries. These endpoints are identified by IPv4 or IPv6 address and are grouped with other endpoints with similar properties into Provider-Defined Identifiers (PIDs) to reduce the size of future queries and responses. A "cost map" lists the routing cost for each pair of PIDs.

The Map-Filtering Service provides a subset of the network map or cost map based on client-provided parameters.

The Endpoint Property Service allows the client to query properties, such as the connectivity type or encapsulating PID, of a specific endpoint.

The Endpoint Cost Service gives clients the routing cost to specific endpoints, which might be expressed as the absolute cost metric or a ranking of the relative cost of each.

Later specifications specify additional services:

The Update Stream Service, specified in RFC 8895,[15] leaves the connection open for the server to provide a stream of update messages as information changes. The same RFC also specifies the Stream Control Service, allowing the client to change its request for update messages.

All ALTO client messages are REST HTTP requests that elicit HTTP responses from the ALTO server. The payloads of these requests and responses consist of JSON text that contain hierarchical key-value pairs.

Protocol syntax

Clients obtain the IRD via the HTTP GET message. The following example from RFC 7285 depicts a request for the IRD. The requested target (/directory) came from the DDDS service discovery process described above. This IRD provides targets for the services available on this server, as well as acceptable parameters.

GET /directory HTTP/1.1
Host: alto.example.com
Accept: application/alto-directory+json,application/alto-error+json
HTTP/1.1 200 OK
Content-Length: 2333
Content-Type: application/alto-directory+json

{
  "meta" : {
    "cost-types": {
      "num-routing": {
        "cost-mode"  : "numerical",
        "cost-metric": "routingcost",
        "description": "My default"
      },
      "num-hop":     {
        "cost-mode"  : "numerical",
        "cost-metric": "hopcount"
      },
      "ord-routing": {
        "cost-mode"  : "ordinal",
        "cost-metric": "routingcost"
      },
      "ord-hop":     {
        "cost-mode"  : "ordinal",
        "cost-metric": "hopcount"
      }
    },
    "default-alto-network-map" : "my-default-network-map"
  },
  "resources" : {
    "my-default-network-map" : {
      "uri" : "http://alto.example.com/networkmap",
      "media-type" : "application/alto-networkmap+json"
    },
    "numerical-routing-cost-map" : {
      "uri" : "http://alto.example.com/costmap/num/routingcost",
      "media-type" : "application/alto-costmap+json",
      "capabilities" : {
        "cost-type-names" : [ "num-routing" ]
      },
      "uses": [ "my-default-network-map" ]
    },
    "numerical-hopcount-cost-map" : {
      "uri" : "http://alto.example.com/costmap/num/hopcount",
      "media-type" : "application/alto-costmap+json",
      "capabilities" : {
        "cost-type-names" : [ "num-hop" ]
      },
      "uses": [ "my-default-network-map" ]
    },
    "custom-maps-resources" : {
      "uri" : "http://custom.alto.example.com/maps",
      "media-type" : "application/alto-directory+json"
    },
    "endpoint-property" : {
      "uri" : "http://alto.example.com/endpointprop/lookup",
      "media-type" : "application/alto-endpointprop+json",
      "accepts" : "application/alto-endpointpropparams+json",
      "capabilities" : {
        "prop-types" : [ "my-default-network-map.pid",
                         "priv:ietf-example-prop" ]
      },
    },
    "endpoint-cost" : {
      "uri" : "http://alto.example.com/endpointcost/lookup",
      "media-type" : "application/alto-endpointcost+json",
      "accepts" : "application/alto-endpointcostparams+json",
      "capabilities" : {
        "cost-constraints" : true,
        "cost-type-names" : [ "num-routing", "num-hop",
                              "ord-routing", "ord-hop"]
      }
    }
  }
}

Clients obtain the Map Service via the HTTP GET message. The following example from RFC 7285 depicts a request for a network map and a response that groups five endpoints into 3 PIDs:

GET /networkmap HTTP/1.1
Host: alto.example.com
Accept: application/alto-networkmap+json,application/alto-error+json
HTTP/1.1 200 OK
Content-Length: 449
Content-Type: application/alto-networkmap+json

{
  "meta" : {
    "vtag": {
      "resource-id": "my-default-network-map",
      "tag": "da65eca2eb7a10ce8b059740b0b2e3f8eb1d4785"
    }
  },
  "network-map" : {
    "PID1" : {
      "ipv4" : [
        "192.0.2.0/24",
        "198.51.100.0/25"
      ]
    },
    "PID2" : {
      "ipv4" : [
        "198.51.100.128/25"
      ]
    },
    "PID3" : {
      "ipv4" : [
        "0.0.0.0/0"
      ],
      "ipv6" : [
        "::/0"
      ]
    }
  }
}

The other three services rely on additional information the client provides in the request payload. As HTTP GET does not have a request payload, clients access these services with the HTTP POST method. The following example from RFC 7285 shows a request for the cost from one source to three potential destinations, and the response.

POST /endpointcost/lookup HTTP/1.1
Host: alto.example.com
Content-Length: 248
Content-Type: application/alto-endpointcostparams+json
Accept: application/alto-endpointcost+json,application/alto-error+json

{
  "cost-type": {"cost-mode" : "ordinal",
                "cost-metric" : "routingcost"},
  "endpoints" : {
    "srcs": [ "ipv4:192.0.2.2" ],
    "dsts": [
      "ipv4:192.0.2.89",
      "ipv4:198.51.100.34",
      "ipv4:203.0.113.45"
    ]
  }
}
HTTP/1.1 200 OK
Content-Length: 274
Content-Type: application/alto-endpointcost+json
{
  "meta" : {
    "cost-type": {"cost-mode" : "ordinal",
                  "cost-metric" : "routingcost"
    }
  },
  "endpoint-cost-map" : {
    "ipv4:192.0.2.2": {
      "ipv4:192.0.2.89"    : 1,
      "ipv4:198.51.100.34" : 2,
      "ipv4:203.0.113.45"  : 3
    }
  }
}

Other extensions

Numerous additional standards have extended the protocol's usability and feature set.

  • RFC 8189[16] allows clients to request multiple cost types (for example, routing cost and hop count) in a single request.
  • RFC 8896[17] introduces the concept of a "cost calendar", where the server can express how the cost to reach an endpoints evolves over time.
  • The IETF Datatracker for the ALTO working group[11] shows documents that are still work in progress.

References

  1. 1.0 1.1 Seedorf, Jan; Burger, Eric (October 2009), Application-Layer Traffic Optimization (ALTO) Problem Statement, IETF, doi:10.17487/RFC5693, RFC 5693, https://tools.ietf.org/html/rfc5693 
  2. 2.0 2.1 Alimi, Richard; Penno, Reinaldo; Yang, Richard; Kiesel, Sebastian; Prevedi, Stefano; Roome, Wendy; Shalunov, Stanislav; Woundy, Richard (September 2014), Application-Layer Traffic Optimization (ALTO) Protocol, IETF, doi:10.17487/RFC7285, RFC 7285, https://tools.ietf.org/html/rfc7285 
  3. 3.0 3.1 Kiesel, Sebastian; Prevedi, Stefano; Stiemerling, Martin; Woundy, Richard; Yang, Richard (September 2012), Application-Layer Traffic Optimization (ALTO) Requirements, IETF, doi:10.17487/RFC6708, RFC 6708, https://tools.ietf.org/html/rfc6708 
  4. Kravets, David (September 19, 2008). "Comcast Discloses Throttling Practices - BitTorrent Targeted". wired.com. https://www.wired.com/2008/09/comcast-disclos-2/. 
  5. Peterson, Jon; Cooper, Alissa (July 2009), Report from the IETF Workshop on Peer-to-Peer (P2P) Infrastructure, May 28, 2008, IETF, doi:10.17487/RFC5594, RFC 5594, https://tools.ietf.org/html/rfc5594 
  6. "Decoupled Application Data Enroute (decade)". IETF. https://datatracker.ietf.org/wg/decade/about/. 
  7. Shalunov, Stanislav; Hazel, Greg; Iyengar, Janardhan; Kuehlewind, Mirja (December 2012), Low Extra Delay Background Transport (LEDBAT), IETF, doi:10.17487/RFC6817, RFC 6817, https://tools.ietf.org/html/rfc6817 
  8. Bless, Roland (June 2019), A Lower-Effort Per-Hop Behavior (LE PHB) for Differentiated Services, IETF, doi:10.17487/RFC8622, RFC 8622, https://tools.ietf.org/html/rfc8622 
  9. "WG Action: Application-Layer Traffic Optimization (alto)". IESG Secretary. November 12, 2008. https://mailarchive.ietf.org/arch/msg/ietf-announce/UsI1Iu3aPaJQ104U3plRultx7jU/. 
  10. 10.0 10.1 Kiesel, Sebastian; Stiemerling, Martin; Schwan, Nico; Scharf, Michael; Song, Haibin (November 2014), Application-Layer Traffic Optimization (ALTO) Server Discovery, IETF, doi:10.17487/RFC7286, RFC 7286, https://tools.ietf.org/html/rfc7286 
  11. 11.0 11.1 "IETF Datatracker: Application-Layer Traffic Optimization (ALTO)". IETF. https://datatracker.ietf.org/wg/alto/documents/. 
  12. Stiemerling, Martin; Kiesel, Sebastian; Scharf, Michael; Seidel, Hans; Prevedi, Stefano (October 2016), Application-Layer Traffic Optimization (ALTO) Deployment Considerations, IETF, doi:10.17487/RFC7971, RFC 7971, https://tools.ietf.org/html/rfc7971 
  13. Gurbani, Vijay K.; Seedorf, Jan (June 2020). "Evolution of the IETF Application Layer Traffic Optimization (ALTO) Protocol". IEEE Communications Standards Magazine 4 (2): 9. doi:10.1109/MCOMSTD.2020.9139037. https://ieeexplore.ieee.org/document/9139037. Retrieved July 2, 2021. 
  14. Kiesel, Sebastian; Stiemerling, Martin (February 2020), Application-Layer Traffic Optimization (ALTO) Cross-Domain Server Discovery, IETF, doi:10.17487/RFC8686, RFC 8686, https://tools.ietf.org/html/rfc8686 
  15. Roome, Wendy; Yang, Richard (November 2020), Application-Layer Traffic Optimization (ALTO) Incremental Updates Using Server-Sent Events (SSE), IETF, doi:10.17487/RFC8895, RFC 8895, https://tools.ietf.org/html/rfc8895 
  16. Randriamasy, Sabine; Roome, Wendy; Schwan, Nico (October 2017), Multi-Cost Application-Layer Traffic Optimization (ALTO), IETF, doi:10.17487/RFC8189, RFC 8189, https://tools.ietf.org/html/rfc8189 
  17. Randriamasy, Sabine; Yang, Richard; Wu, Qin; Deng, Lingli; Schwan, Nico (November 2020), Application-Layer Traffic Optimization (ALTO) Cost Calendar, IETF, doi:10.17487/RFC8896, RFC 8896, https://tools.ietf.org/html/rfc8896