<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Mark Cahill on Medium]]></title>
        <description><![CDATA[Stories by Mark Cahill on Medium]]></description>
        <link>https://medium.com/@thinkjson?source=rss-8052c0c59f05------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*tZ5oNTfwuPyH40JQTtN9nw.jpeg</url>
            <title>Stories by Mark Cahill on Medium</title>
            <link>https://medium.com/@thinkjson?source=rss-8052c0c59f05------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 18:54:26 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@thinkjson/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Building a Microservice API Gateway for iHeartRadio’s Radio Station Network with GraphQL]]></title>
            <link>https://tech.iheart.com/building-a-microservice-api-gateway-for-iheartradios-radio-station-network-with-graphql-5f9ddb37a314?source=rss-8052c0c59f05------2</link>
            <guid isPermaLink="false">https://medium.com/p/5f9ddb37a314</guid>
            <category><![CDATA[api]]></category>
            <category><![CDATA[schema-stitching]]></category>
            <category><![CDATA[microservices]]></category>
            <category><![CDATA[apollo-server]]></category>
            <category><![CDATA[graphql]]></category>
            <dc:creator><![CDATA[Mark Cahill]]></dc:creator>
            <pubDate>Mon, 22 Oct 2018 12:58:25 GMT</pubDate>
            <atom:updated>2018-10-22T13:48:44.631Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rc9zhJ-2f5jIeK8N5ltMSA.png" /><figcaption><a href="https://www.flickr.com/photos/volcan96/3764345256/in/photolist-6JDfGq-dEZfZV-BLF5ob-831Cmv-6fwXRM-bXW6yS-YKguiJ-bW8zLK-dmp2sj-GoDn1M-AgnGBf-rEAQmU-uXMeFY-wJXneA-NPi1Jx-ui9DdS-NgJSa3-4M4bYC-c5os9U-bFaiFd-4Hf83h-Df5htm-qiQMfK-9NHDco-oSYBRz-ny6ki8-nJkeCK-4VqGzP-8hJ4zN-6ss5t1-9KrX2Y-ocnWTh-eEUkWX-cT1oPd-7RMw5C-Wvkdqt-cT1t89-9M4xxF-myk8Jw-cKn9fQ-pCeWNw-c2nAq3-6h1nhM-S59Pzk-27iFBoe-8BgjXR-JH4TGS-8cEjcB-acRspx-o4gB38">Photo</a> by <a href="https://www.flickr.com/photos/volcan96/">volcan96</a> / <a href="https://creativecommons.org/licenses/by/2.0/">CC BY</a></figcaption></figure><p>Much has been written about how microservices ease many of the problems with modern web application development. Martin Fowler wrote an article entitled <a href="https://martinfowler.com/articles/microservice-trade-offs.html">Microservice Trade-Offs</a> which explains that microservices provide strong module boundaries, allow you to deploy pieces of your infrastructure independently of one another, and enable you to mix different technologies and frameworks in the same application. Amazon wrote a white paper on the subject called <a href="https://docs.aws.amazon.com/aws-technical-content/latest/microservices-on-aws/benefits-of-microservices.html">Benefits of Microservices</a>, also highlighting the fact that microservices can be scaled independently of one another and isolate failures to a single microservice in the event of a failure.</p><p>Though very useful, microservices do have their challenges. They can be hard to deploy and monitor. It can be hard to maintain data consistency across the application. It can also be difficult to maintain a clean, consistent API interface across all microservices. In this article, I’ll talk about how iHeartRadio utilizes GraphQL, a query language for your API, to serve as an API gateway for our microservices. GraphQL is an interface to your API which provides a complete and understandable description of what data is provided by your API, and gives clients the power to ask for exactly what they need and nothing more, making it easier to evolve your API over time.</p><p>I’ve put together a <a href="https://graphql.thinkjson.com/">sample application</a> that succinctly demonstrates many of the topics I’ll cover in this article. The source code for both the <a href="https://github.com/thinkjson/graphql-example">API gateway</a> and the <a href="https://github.com/thinkjson/countries">underlying microservice</a> are available for reference, and I’ll highlight sections of the code as we step through each feature.</p><h3>Providing a consistent API interface</h3><p>Some companies sidestep the issue of providing a consistent API interface, simply providing multiple APIs with which to interact with their platform. This adds complexity to the client code, and can be frustrating for API users. In this model, each API also tends to reflect the underlying implementation details and biases of that product and its development team.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/928/1*Mp1RMA0xCOKXeVSTfw36aA.png" /><figcaption>Not great. I have to query each product separately for data.</figcaption></figure><p>Other companies develop a monolithic API interface to their platform. This allows you to provide a single consistent API interface, making it easier for client developers to integrate with your API, but presents other challenges. REST APIs don’t generally allow you to specify in the request what data you are interested in. What this means, in practice, is that you end up with a variety of overlapping APIs that meet the various needs of your API clients. Also, you incur overhead to fetch data that the client doesn’t necessarily care about. You also have trouble with isolating service failures.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/925/1*6OdQkKlHB6j_xVeVHc0uPQ.png" /><figcaption>This is a little better. While requests for data from Products 1 and 2 were combined into a single request, I also paid the overhead of fetching data from Product 3.</figcaption></figure><h3>Aggregating your microservices using an API gateway</h3><p>At iHeartRadio, we use microservices to implement the various pieces of our application’s architecture, separating the management of content, stream data, contests, and other metadata into their own microservices. However, at the end of the day, our client developers (web, mobile, and auto) still want a single, consistent interface to request the data they need to develop their applications. What we needed was to aggregate our microservices in order to present a unified interface to our client developers.</p><p>Aggregating APIs is similar to the Facade pattern in object-oriented design, only in a distributed system. In the facade pattern, you expose objects and methods that represent the mental model that users have about the real-world objects that these classes represent. This interface serves to allow users to interact with the system without being exposed to the complexity of the underlying implementation details. In his <a href="https://martinfowler.com/eaaCatalog/remoteFacade.html">explanation of the “remote facade” design pattern</a>, Martin Fowler states that this pattern “gives you lots of opportunity… to use good intention revealing naming to make an application easier to understand”. These are the same goals we have when developing a public API interface to our microservices.</p><p>When applied to a distributed system, this pattern is generally called the API gateway. Much in the same way as the facade pattern, the API gateway exposes endpoints that reflect the user’s mental model of the system, and hides the complexity of the underlying microservices that make it work. It was introduced during the service-oriented architecture fad of the early 2000s, and has found a resurgence with companies that want to expose a public API in front of their microservices.</p><p>Microsoft wrote a white paper on best practices for building microservice-based applications on Azure. In that article, entitled <a href="https://docs.microsoft.com/en-us/dotnet/standard/microservices-architecture/architect-microservice-container-applications/direct-client-to-microservice-communication-versus-the-api-gateway-pattern">The API Gateway pattern versus the Direct client-to-microservice communication</a>, they explain that directly integrating clients with multiple microservices presents some challenges.</p><p>First, there is the chattiness problem. There may be actions that require notifying multiple microservices of an event, or fetching data from multiple microservices. Not only does this increase the quantity of requests, which may cause performance problems in clients sensitive to latency such as mobile applications, but a failure of any one of these requests then needs to be handled by the client, increasing the complexity of the client code.</p><p>Second, there are cross-cutting concerns that now have to be dealt with in each microservice, such as authorization, data transformation, and dynamic request dispatching. This results in a duplication of effort for each microservice that you spin up.</p><p>Third, servers may use protocols that are not necessarily friendly to clients. For example, at iHeartRadio, many of our internal services use protocol buffers to communicate with one another. Moving this internal communication to an API gateway ensures that clients can communicate with our API using JSON over HTTPS.</p><p>API gateways solve these issues by aggregating multiple API calls, handling cross-cutting concerns such as authentication and authorization, and abstracting away internal communication protocols. They also provide many other benefits. An API gateway allows you to tailor your APIs to your mobile clients by reducing the quantity of data that gets sent to them. They allow you to maintain loose coupling between your clients and your microservices. They provide a single point at which to cache responses, retry failed requests, enforce rate limiting and throttling, log errors and other diagnostic data, manipulate headers and transform response data, and whitelist clients by IP.</p><p>In 2012, Netflix was experiencing many of the same problems with clients needing different representations of the platform’s data. In their <a href="https://medium.com/netflix-techblog/embracing-the-differences-inside-the-netflix-api-redesign-15fd8b3dc49d">explanation of their API redesign</a>, they explain that they chose to abandon their monolithic API gateway, and instead turn their API into a platform on which client developers could build the APIs they needed for their applications. This led to a proliferation of what they called “content adapters” as client development teams tailored their own API experience to their team’s needs. This was a foreshadowing of what was to come in GraphQL, which, in my opinion, solves these problems much more elegantly.</p><h3>Using GraphQL as an API gateway</h3><p>At iHeartRadio, we found that GraphQL provides a lot of advantages for the API aggregation use case. GraphQL is an interface for your API that provides users with a query language that allows them to ask for exactly the data they need and nothing more. It also provides powerful development tools to ease API integration.</p><p>We chose a TypeScript implementation called <a href="https://www.apollographql.com/docs/apollo-server/">Apollo Server</a> to use as our API gateway. Apollo Server can operate as a standalone Node.js server, like we run it, or you can integrate it into an existing Node.js application in order to provide a GraphQL interface.</p><p>GraphQL has a number of concepts which solve the API gateway problem elegantly. It has the concept of a resolver, which lazy loads portions of a document based on the client’s request, allowing the client to tailor what information is included in the server response. It has the concept of a data loader, which provides an easy mechanism for caching that data. You can use a feature called schema stitching to prevent duplication of effort when changes are made to your microservices. GraphQL gracefully degrades in the event of a service outage, providing what data it can to the client about the error without failing the entire request. API documentation is built into Apollo Server. It checks a lot of the boxes for an API gateway, and does so in a way that solves many of the challenges that developers have faced building their own API gateways.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/925/1*uKYZtdqukcYyvismcDEkSA.png" /><figcaption>Heck yes. I can fetch data from Products 1 and 2 without incurring the overhead of fetching data from Product 3.</figcaption></figure><h3>Using resolvers to conditionally load or mutate data</h3><p>The needs of the web team, mobile application teams, and auto team are very similar. They want to be able to fetch data such as a radio station’s “now playing” metadata. However, sometimes clients have different needs. On Z100.com, for example, there is a need to fetch a list of the most recently published articles so they can be displayed on Z100’s homepage. However, an auto integration has no need for this type of data. To solve this problem, we expose what GraphQL calls a resolver for each type of data.</p><p>A resolver is essentially a function that specifies how that data should be fetched. GraphQL lazy loads data, so resolvers that are not included in a query never get executed. This allows client developers to tailor their queries to their individual needs, and avoid the overhead of fetching data that the client is not interested in, improving the performance of the client application. In this way, Z100.com can include what we call timeline data in their query, while our automotive integrations can exclude it from their query.</p><p>Our sample application provides interfaces to two microservices, one for fetching country data, and one for fetching currency exchange rates. Suppose a client was only interested in the current exchange rate between USD and EUR. The query would look something like this:</p><pre>query {<br>    currency(symbol: [“USD”]) {<br>        symbol<br>        exchange<br>    }<br>}</pre><p>In our resolver definition, we would target the currency resolver of the query. That would look something like this:</p><pre>const resolvers = {<br>    <strong>Query</strong>: {<br>        ...<br>        <strong>currency</strong>: async (<br>            args: any,<br>            vars: Partial&lt;CurrencyInput&gt;<br>        ): Promise&lt;CurrencyOutput[] | null&gt; =&gt; {<br>            if (!vars.symbol) {<br>                return null;<br>            }</pre><pre>            return await currencyLoader().loadMany(vars.symbol);<br>        }<br>    }<br>};</pre><p>The currency resolver fetches the required information from the currency DataLoader, and none of the code related to country information ever executes. In addition, the response only includes the specific information the client was interested in, and nothing more.</p><h3>Using schema stitching to combine multiple APIs</h3><p>When defining what data is available to clients, GraphQL requires that you specify a schema for your data. This is a representation of your data model that relates to the response format of each of your resolvers. For example, the schema for our currency endpoint looks like this:</p><pre>type Currency {<br>    symbol: String<br>    exchange: Float<br>}</pre><pre>type Query {<br>    currency(symbol: [String]): [Currency]<br>}</pre><p>We define a new query called “currency” that takes one parameter, a list of strings, and returns a list of Currency objects. This not only determines the response format of the resolver, but auto-generates documentation for your client developers. However, if you are integrating multiple microservices, it can be tedious and unproductive to redefine the schema from each of them.</p><p>Apollo Server addresses this concern by allowing you to import the underlying microservice’s schema and merge it with the rest of your schema, delegating the execution of that resolver to the underlying GraphQL service. This feature, called <a href="https://www.apollographql.com/docs/graphql-tools/schema-stitching.html">schema stitching</a>, allows you to expose each of your microservices in the schema on your API gateway as long as they also expose a GraphQL interface.</p><p>When instantiating your ApolloServer instance, you pass in the schema that represents all of the data available in your application.</p><pre>const server = new ApolloServer({<br>    <strong>schema</strong>,<br>    ...</pre><p>Apollo gives you the ability to merge multiple schema together when building your application. This can be useful not just for schema stitching, but also if you’re just creating a modular application architecture in a single service.</p><pre>const schema = <strong>mergeSchemas</strong>({<br>    schemas: [<strong>countrySchema, currencySchema</strong>],<br>    resolvers<br>});</pre><p>When using schema stitching, the schema passed into this merge is actually defined remotely. You specify an HttpLink to the url of the remote GraphQL service, then tell Apollo to inspect the remote schema so that it can be merged with the rest of your schema.</p><pre>const createRemoteSchema = async (uri: string) =&gt; {?<br>    const link = new HttpLink({ uri, fetch: fetch as any });<br>    const schema = <strong>makeRemoteExecutableSchema</strong>({<br>        schema: await <strong>introspectSchema</strong>(link),<br>        link,<br>    });</pre><pre>    return schema;<br>}</pre><p>One of the main complaints with the API gateway pattern is that each change to an underlying microservice requires a corresponding change to the API gateway. This is still true when using GraphQL without schema stitching because each change to the underlying microservice must be reflected in the schema of the API gateway. By stitching in the schema from the remote GraphQL endpoint, you can avoid making those changes twice, automatically propagating changes on the microservice to the API gateway.</p><h3>Graceful degradation during a service outage</h3><p>The golden rule of distributed systems is that failure is inevitable. When you start to have dozens of microservices as we have, it is essential that you build your API gateway to gracefully degrade when services are unavailable. RisingStack wrote a really good article about <a href="https://blog.risingstack.com/designing-microservices-architecture-for-failure/">designing your microservice architecture for failure</a>. In this article, they recommend building your application such that service outages only disable certain functionality instead of taking the entire application down.</p><p>When writing an API gateway to expose functionality from each of our microservices, it is common that requesting data fails because one of the underlying services is temporarily unavailable. Error handling is needed to determine what to do in these failure scenarios.</p><p>GraphQL solves this problem elegantly by allowing resolvers to report errors to the client without terminating the entire request (see their documentation on <a href="https://www.apollographql.com/docs/apollo-server/features/errors.html">Error Handling</a>). In this way, clients can be made aware of service outages when requesting data, and react to the data that is available. Then they can potentially retry only the failing portion of the request at a future time by simply modifying the client query to backfill the missing data.</p><p>For example, say a client was interested in both country and currency data. The query might look something like this:</p><pre>query {<br>    country(code: “US”) {<br>        name<br>        languages {<br>            name<br>        }<br>    }<br>    currency(symbol: “USD”) {<br>        exchange<br>    }<br>}</pre><p>If the currency service was unavailable, GraphQL would report the error, but still return the country data that it was able to successfully fetch. The response might look something like this:</p><pre>{<br>    “data”: {<br>        “country”: {<br>            “name”: “United States”,<br>            “languages”: [<br>                { “name”: “English” }<br>            ]<br>        },<br>        <strong>“currency”: null</strong><br>    },<br>    “errors”: [<br>        {<br>            <strong>“message”: “Currency service unavailable”,</strong><br>            ...<br>            “path”: [<br>                “currency”<br>            ],<br>    ...<br>}</pre><p>This would allow the client to work with the country data, and potentially try again later to fetch just the currency data using a query like this:</p><pre>query {<br>    currency(symbol: “USD”) {<br>        exchange<br>    }<br>}</pre><h3>Using data loaders to cache frequently requested data</h3><p>For read-heavy applications with consistent access patterns like ours, caching becomes a really important tool in improving the performance of your API gateway. There is a section in the GraphQL documentation that talks about <a href="https://www.apollographql.com/docs/graphql-tools/connectors.html#dataloader">DataLoader and caching</a>. <a href="https://github.com/facebook/dataloader">DataLoader</a> is a library developed by Facebook to provide a consistent interface for fetching remote data. They developed it as a generic interface to the multitude of key-value stores they were using at the time. It’s a perfect fit for GraphQL services, where you want a single place to abstract the fetching and caching of data. A DataLoader might look something like this:</p><pre>const loader = () =&gt; new DataLoader&lt;string, CurrencyOutput&gt;(<br>    keys =&gt; fetchCurrency(keys)<br>);</pre><p>Then you can use the DataLoader in your resolver like this:</p><pre>return await currencyLoader().loadMany(vars.symbol);</pre><p>In this case, we instantiate an instance of the loader using a factory method to prevent memoization across requests, then use the standard interface “loadMany” to fetch currency data in a batch for the provided symbols. In our DataLoader definition, we use a cache to prevent fetching the same data within a certain period of time. Here is what the currency DataLoader looks like in our sample application:</p><pre>async function fetchCurrency(<br>    keys: string[],<br>): Promise&lt;(CurrencyOutput | Error)[]&gt; {</pre><pre>    // First check cache for these keys<br>    const misses: string[] = [];<br>    const responses: {[key: string]: number} = {};<br>    keys.forEach(key =&gt; {<br>        const value = cache.get(cacheKey(key));<br>        if (value === null) {<br>            misses.push(key);<br>        } else {<br>            responses[key] = value;<br>        }<br>    });<br>    const hits: string[] = Object.keys(responses);<br>    if (hits.length &gt; 0) {<br>        console.log(`cache hit for ${hits.join(“,”)}`);<br>    }</pre><pre>    // Fetch missing keys from the API<br>    if (misses.length) {<br>        const url = `http://data.fixer.io/api/latest?access_key=${FIXER_API_KEY}&amp;symbols=${misses.join(&quot;,&quot;)}&amp;format=1`;<br>        const response = await fetch(url);<br>        const currencyResponse: CurrencyResponse =<br>            await response.json();<br>        console.debug(`cache miss for ${misses.join(“,”)}\n`, currencyResponse);<br>        if (!currencyResponse.success) {<br>            throw new Error(currencyResponse.error<br>                ? currencyResponse.error.info<br>                : “There was an error fetching currency information”);<br>        }</pre><pre>        // Collect responses<br>        Object.keys(currencyResponse.rates).forEach(key =&gt; {<br>            const value = currencyResponse.rates[key];<br>            cache.put(cacheKey(key), value, CACHE_TIME);<br>            responses[key] = value;<br>        });<br>    }</pre><pre>    // Return responses in the same order they were requested<br>    return keys.map((symbol): CurrencyOutput =&gt; {<br>        return { symbol, exchange: responses[symbol] };<br>    });<br>}</pre><p>There’s a lot going on here. First, we check the cache for the keys being passed in, and save these cached results. Next, we determine which symbols we don’t have data for, and fetch those from the remote service, caching the result. Finally, we collect the responses from both the cache and the remote service, and return them to the resolver in the same order in which they were requested.</p><p>In addition to caching data requests in a DataLoader, you can also use HTTP caching and a CDN to improve performance of HTTP requests. This works both from the client to the API gateway, and from the gateway to your microservices. Caching data using a CDN usually consists of setting appropriate caching headers on the API response for a resolver, then putting this API behind a CDN. Ensure you are using GET to access your GraphQL endpoint, or configure your CDN to cache POST requests.</p><p>Apollo Server includes functionality called <a href="https://www.apollographql.com/docs/guides/performance.html#automatic-persisted-queries">automatic persisted queries</a> for specifying what parts of a response can be cached and for how long. You can turn on response caching globally, as well as specifying cache hints for parts of your schema (see the docs on <a href="https://www.apollographql.com/docs/guides/performance.html#cdn">CDN integration</a>). Cache hints can be added to your schema like so:</p><pre>type Continent <strong>@cacheControl(maxAge: 86400)</strong> {<br>    code: String<br>    name: String<br>}</pre><p>Apollo Server will look at both the query and these cache hints, and determine how long to cache the response automatically. This gets applied to the response as a Cache-Control header.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/306/0*2ZwAo0jAmGE89p-o" /></figure><p>In our example API gateway, we also set a default max age that will be used in the absence of cache hints:</p><pre>const server = new ApolloServer({<br>    ...<br>    cacheControl: {<br>        defaultMaxAge: 3600,<br>    },<br>});</pre><p>As an alternative to caching data in your data loader, Apollo Server also includes functionality for <a href="https://www.apollographql.com/docs/apollo-server/v2/features/data-sources.html#Using-Memcached-Redis-as-a-cache-storage-backend">caching data access using memcached</a>. By default, resource caching will use an in-memory LRU cache. However, if you run multiple instances of your API gateway behind a load balancer as we do, you can use memcached to improve cache hit rates by sharing cache between instances.</p><h3>Documenting your APIs</h3><p>Prior to implementing GraphQL, I had used <a href="https://swagger.io/solutions/api-documentation/">Swagger Docs</a> to document public REST APIs. When moving to GraphQL, I was interested in similar functionality to allow API users, in this case our client developers, to interactively explore the data exposed by the API when writing their API integrations. Fortunately, Apollo Server includes something called the <a href="https://www.apollographql.com/docs/apollo-server/features/graphql-playground.html">GraphQL Playground</a>.</p><p>The Playground exposes an interactive explorer for your schema, allowing client developers to see what data is exposed by your server, what parameters are required by each resolver, and how to craft their queries in order to get the data they need.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/928/0*gQ0bws7AqfBohgSS" /></figure><p>It also includes a query interface for testing those queries, as well as advanced tracing capabilities for determining performance bottlenecks and causes of service errors.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*_130tP5jfCBKdYpm" /></figure><h3>tl;dr</h3><p>Microservices can make many aspects of modern web application development easier. They provide a strong boundary between modules, allow for independent scaling of different portions of your application, and allow you to mix different technologies and frameworks. However, microservices present some challenges, such as providing a consistent user experience for API users.</p><p>This problem existed before microservices, and has traditionally been solved by using what is called an API gateway. However, this presents a few problems. It makes it challenging to conditionally query for or mutate data. Changes to microservices necessitate a change to the API gateway. Also, underlying microservices can present a single point of failure.</p><p>GraphQL solves these problems by providing a consistent data access pattern for underlying microservices that combines multiple APIs into a single query interface, and gracefully degrades in the event of a failure. In addition, it makes it easy to cache frequently accessed data, and provides interactive documentation to ease API integration. GraphQL is a solid base upon which to build an API gateway to aggregate your microservices.</p><p><em>Interested in working on problems such as these? iHeartRadio is hiring! Please take a moment to look at our open positions: </em><a href="http://jobs.iheart.com/"><em>http://jobs.iheart.com</em></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5f9ddb37a314" width="1" height="1" alt=""><hr><p><a href="https://tech.iheart.com/building-a-microservice-api-gateway-for-iheartradios-radio-station-network-with-graphql-5f9ddb37a314">Building a Microservice API Gateway for iHeartRadio’s Radio Station Network with GraphQL</a> was originally published in <a href="https://tech.iheart.com/">iHeartRadio Tech</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>