Sécuriser les points de terminaison de la passerelle API AWS en utiilisant des autorisateurs personnalisés

Sécuriser les points de terminaison de la passerelle API AWS en utiilisant des autorisateurs personnalisés qui acceptent les jetons d’accès émis par Auth0. Pour faire cela, vous configurez votre API avec la passerelle API, créez et configurez vos fonctions Lambda AWS (incluant les autorisateurs personnalisés) pour sécuriser vos points de terminaison AWS, et mettez en oeuvre le fllux d’autorisation afin que vos utilisateurs puissent récupérer les jetons d’accès requis pour avoir accès à votre API depuis Auth0.

Pour en savoir plus, visitez Aperçu Lambda AWS une fois connecté à votre Passerelle API AWS.

La passerelle API étend les capacités de Lambda en ajoutant une couche de service devant vos fonctions Lambda pour étendre la sécurité, gérer les transformations des messages d’entrée et de sortie et fournir des capacités telles que la limitation de taux et l’audit. Une approche sans serveur simplifie vos demandes opérationnelles puisque les préoccupations telles que la croissance et la tolérance aux pannes sont désormais de la responsabilité du service de calcul qui exécute votre code.

Les autorisateurs personnalisés vont :

• Confirmer que le jeton d’accès a été transmis via l’en-tête authorization de la demande d’accès à l’API.

• Vérifier la signature RS256 du jeton d'accès à l'aide d'une clé publique obtenue via un point de terminaison JWKS.

• S’assurer que le jeton d’accès comporte les demandes requises de l’émetteur iss et d'audience aud.

Suivez les étapes suivantes pour utiliser des autorisateurs personnalisés :

1. Créer une API Auth0

2. Importer et déployer l’API passerelle AWS API.

3. Créer les autorisateurs personnalisés

4. Sécuriser l’API à l’aide d’autorisateurs personnalisés

5. Tester votre déploiement

Pour en savoir plus sur les algorithmes de signature, lisez Algorithmes de signature. Pour plus de détails sur l’utilisation de JWKS, consultez JSON Web Key Sets (Ensembles de clés JSON Web).

Selon Amazon, un autorisateur personnalisé de passerelle API est une « fonction Lambda que vous fournissez pour contrôler l’accès à votre API à l’aide de stratégies d’authentification par jeton du porteur, telles que OAuth ou SAML ».

Chaque fois qu’une personne (ou un programme) tente d’appeler votre API, la passerelle API vérifie si un autorisateur personnalisé est configuré pour l’API.

S’il existe un autorisateur personnalisé pour l’API, la passerelle API appelle l’autorisateur personnalisé et fournit le jeton d’autorisation extrait de l’en-tête de la demande reçue.

Vous pouvez utiliser l'autorisateur personnalisé pour mettre en œuvre différents types de stratégies d'autorisation, y compris la vérification JWT, pour renvoyer des politiques IAM autorisant la demande. Si la politique renvoyée n'est pas valide ou si les autorisations sont refusées, l'appel à l'API échoue.

Dans le cas d’une politique valide, l’API met en cache la politique renvoyée, l’associe au jeton entrant et l’utilise pour la demande actuelle et les demandes suivantes. Vous pouvez configurer la durée pendant laquelle la politique est mise en cache. La valeur par défaut est 300 secondes et la durée maximale de mise en cache est 3600 secondes (vous pouvez également fixer la valeur à 0 pour désactiver la mise en cache).

Pour en savoir plus, consultez What is Amazon API Gateway? (Qu’est-ce que la passerelle API Amazon) dans le Amazon Developer’s Guide. Pour plus d’informations sur la vérification des JWT, consultez notre article Jeton Web JSON .

Vous devez vous inscrire à un compte AWS. Cela vous permet d’accéder aux fonctionnalités AWS, notamment API Gateway et Lambda. Tous les nouveaux membres bénéficient de douze mois d’accès gratuit à AWS.

Configurer les API consommées par les applications qui réussissent à obtenir une autorisation.

1. Rendez-vous au Tableau de bord Auth0 > Applications > API, et sélectionnez Créer une API.

2. Saisissez les valeurs des champs suivants et sélectionnez Créer.

   Champ	Description
   Name	Un nom convivial pour votre API. C’est le nom que vous verrez dans votre liste d’API Auth0.
   Identifier	Identifiant unique pour votre API. Nous vous recommandons de formater cet identifiant comme une URL https://your-api-gateway.
   Profil de jeton Web JSON	Profil de jeton OAuth2.0 ou dialectes, pour un jeton d’accès. Pour en savoir plus, veuillez consulter [Profils de jetons d’accès]
   (/secure/tokens/access-tokens/access-token-profiles)

Pour voir les détails de votre API nouvellement créée, reportez-vous à la vue Paramètres.

La création d’une API crée également une application Machine à Machine à utiliser avec l’API. Cette application est répertoriée comme Authorized (Autorisée) dans la vue Application machine à machine. Prenez note de l’ID client, vous en aurez besoin dans la partie 3 de ce tutoriel.

Au cours de cette étape, vous allez :

• Importer une API dans la Passerelle API

• Tester une importation d’API

• Déployer une API pour l’utiliser avec n’importe quelle application frontale

• Tester le déploiement d’une API

1. Connectez-vous à votre compte AWS et, à l’aide du menu déroulant Services situé dans la barre de navigation supérieure, accédez à la console API Gateway (Passerelle API).

2. Si vous avez déjà créé une API, accédez simplement à la console de la passerelle API et cliquez sur Create API (Créer une API). Vous aurez la possibilité de créer l’API Example API sur le formulaire Create new API (Créer une nouvelle API). Si vous n’avez jamais créé d’API à l’aide de API Gateway Passerelle API), vous verrez l’écran suivant. Cliquez sur Get Started (Commencer) pour continuer.

   

   Vous verrez un message contextuel vous souhaitant la bienvenue dans la Passerelle API. Cliquez sur OK pour continuer.

3. Sur le formulaire Create new API (Créer une nouvelle API), vous verrez que Example API est sélectionné par défaut et qu’un exemple d’API est défini dans l’éditeur. Nous utiliserons cette API pour le reste de notre tutoriel, alors commencez le processus de création d’API en cliquant sur Import (Importer).

   

   Lorsque cela est fait, AWS affiche un message indiquant que votre API a été créée et alimentée avec les données fournies. Vous remarquerez que des méthodes sont déjà associées à l’API (à savoir GET et POST). Vous pouvez afficher les détails d’une méthode, modifier sa configuration ou tester l’invocation de la méthode en cliquant sur le nom de la méthode dans l’arborescence des ressources.

   

Pour tester votre API, cliquez sur POST sous /pets. La fenêtre Method Execution (Exécution de la méthode) s’affiche et donne un aperçu de la structure et des comportements de la méthode POST :

• Method Request (Requête de méthode) et Method Response (Réponse de méthode) : l’interface de l’API avec le front-end

• Integration Request (Requête d’intégration) et Integration Response (Réponse d’intégration) : l’interface de l’API avec le back-end

Nous pouvons utiliser cette zone pour tester l’API.

1. Cliquez sur Test (indiqué sur le ruban Client situé au milieu de la page). Vous serez redirigé vers la page /pets - POST - Method Test (Test de méthode - POST - /pets). Faites défiler jusqu’au bas de la page et fournissez l’extrait suivant en tant que Corps de la demande :

   {"type": "dog", "price": 249.99}

   Was this helpful?

   Yes /No
   Le corps de la demande indique les attributs de l’animal que nous voulons ajouter à la base de données, ainsi que le coût de l’animal.
   

2. Cliquez sur Test pour continuer. Vous verrez les résultats du test dans la partie droite de la page.

   

Le test que nous venons de réaliser a été effectué à l’aide de la console passerelle API. Pour utiliser l’API avec une autre application, vous devrez déployer l’API sur une version de développement.

1. Dans le menu Actions, sélectionnez Déployer API.

2. Indiquez les valeurs suivantes et cliquez sur Déployer.

   Paramètre	Valeur
   Étape de déploiement	Choisir [Nouvelle étape]
   Nom de l’étape	Indiquez un nom pour votre étape
   Description de l’étape	Décrivez votre étape
   Description du déploiement	Décrivez votre déploiement API

Lorsque l’API a été déployée avec succès, vous êtes redirigé vers Test Stage Editor (Éditeur de test de développement). Vous pouvez, à ce stade, tester l’API pour voir si elle s’est déployée correctement.

1. En haut de la fenêtre Test Stage Editor (Éditeur de test de développement) se trouve une bannière bleue avec votre Invoke URL. Il s’agit de l’URL utilisé pour invoquer le point de terminaison GET de votre API. Cliquez sur le lien pour soumettre la demande GET /method dans un navigateur. Vous devriez obtenir la réponse suivante :

   

2. Dans la page Stages (Stades), développez l’arbre sous Test. Cliquez sur GET sous /pets/{petId}.

   

3. Vous verrez une URL Invoke affichée dans la bannière bleue en haut de la fenêtre. La dernière partie, {petID}, représente une variable de chemin. Remplacez cette variable par 1 et accédez la nouvelle URL à l’aide de votre navigateur. Vous devriez recevoir une requête HTTP 200 avec la charge utile JSON suivante :

   {
     "id": 1,
     "type": "dog",
     "price": 249.99
   }

   Was this helpful?

   Yes /No

Maintenant que nous disposons d’une API entièrement fonctionnelle gérée par API Gateway, sécurisez cette API afin que seules les personnes disposant de l’autorisation appropriée puissent accéder au back-end derrière l’API.

Utilisez les autorisateurs de requête personnalisés de API Gateway (Passerelle API) pour autoriser vos API à l’aide de stratégies d’autorisation par jeton du porteur, telles que OAuth 2.0 ou SAML. Pour chaque demande entrante, il se produit ce qui suit :

1. API Gateway (Passerelle API) vérifie la présence d’un autorisateur personnalisé correctement configuré.

2. API Gateway (Passerelle API) appelle l’autorisateur personnalisé (qui est une fonction Lambda) avec le jeton d’autorisation.

3. Si le jeton d’autorisation est valide, l’autorisateur personnalisé renvoie les politiques AWS Identity and Access Management (IAM) appropriées.

4. API Gateway (Passerelle API) utilise les politiques renvoyées à l’étape 3 pour autoriser la demande.

Vous pouvez télécharger un exemple d’autorisateur personnalisé qui prend en charge les jetons émis par Auth0. Par la suite, vous devrez personnaliser les fichiers pour que l’autorisateur personnalisé fonctionne dans votre environnement.

1. Décompressez le dossier contenant les fichiers d’exemple que vous avez téléchargés ci-dessus à l’emplacement de votre choix, et accédez au dossier à l’aide de la ligne de commande.

2. Dans le dossier d’exemple, exécutez npm install pour installer les packages Node.js nécessaires au déploiement; AWS exige que ces fichiers soient inclus dans le paquet que vous téléchargerez sur AWS lors d’une étape ultérieure.

3. Configurez votre environnement local avec un fichier .env. Vous pouvez copier le fichier .env.sample (tout en le renommant .env) en utilisant cp .env.sample .env. Apportez les modifications suivantes :

   Paramètres	Valeur
   TOKEN_ISSUER	L’émetteur du jeton. Si Auth0 est l’émetteur du jeton, utilisez https://{yourDomain}/. Assurez-vous d’inclure la barre oblique.
   JWKS_URI	L’URL du point de terminaison JWKS. Si Auth0 est l’émetteur du jeton, utilisez https://{yourDomain}/.well-known/jwks.json
   AUDIENCE	La valeur de l’identifiant de l’API que vous avez créée dans la section Créer une API Auth0 ci-dessus.

   À titre d’exemple, le texte de votre fichier .env devrait ressembler à ceci une fois terminé :

   JWKS_URI=https://{yourDomain}/.well-known/jwks.json
   AUDIENCE=https://your-api-gateway
   TOKEN_ISSUER=https://{yourDomain}/

   Was this helpful?

   Yes /No

Obtenir un jeton d’accès JWT valide. Il y a plusieurs façons d’en obtenir un et la méthode que vous choisissez dépend du type de votre application, du niveau de confiance ou de l’expérience globale de l’utilisateur final. Pour plus d’informations, consultez Obtenir des jetons d’accès.

1. Vous pouvez obtenir un jeton de test pour votre API en naviguant vers Auth0 Dashboard > Applications > API, en sélectionnant votre API et en sélectionnant Test.

2. Créez un fichier local event.json contenant le jeton. Vous pouvez copier le fichier d’exemple (exécutez cp event.json.sample event.json). Remplacez ACCESS_TOKEN par votre jeton JWT et methodArn par la valeur ARN appropriée pour la méthode GET de votre API.

Pour obtenir methodArn :

1. En utilisant la console de la passerelle API, ouvrez l’API PetStore.

2. Dans la navigation de gauche, sélectionnez Resources.

3. Dans le panneau central Ressources, développez l’arborescence des ressources. Sous /pets, sélectionnez GET.

4. Dans la boîte Requête de méthode, vous verrez ARN.

5. Exécutez le test en utilisant npm test.

lambda-local pour tester l’autorisateur personnalisé en utilisant votre jeton. Si le test a réussi, vous obtiendrez résultat similaire à :

Message
------
{
    "principalId": "C8npTEMVnBrILsBTI91MOh6dfuZbPVAU@clients",
    "policyDocument": {
        "Version": "2012-10-17",
        "Statement": [
            {
                "Action": "execute-api:Invoke",
                "Effect": "Allow",
                "Resource": "arn:aws:execute-api:us-east-1:1234567890:apiId/stage/method/resourcePath"
            }
        ]
    },
    "context": {
        "scope": "FULL_LIST_OF_SCOPES"
    }
}

Si la valeur de Effect (Effet) est Allow (Autoriser), votre authorizer aurait autorisé l’appel à API Gateway (Passerelle API).

Pour en savoir plus, visitez Lambda-local sur NPM.

Le rôle IAM dispose des autorisations requises pour appeler les fonctions Lambda. Avant de pouvoir procéder avec notre autorisateur personnalisé, nous devons créer un rôle IAM qui peut appeler notre autorisateur personnalisé chaque fois que API Gateway (Passerelle API) reçoit une demande d’accès.

1. Connectez-vous à AWS et accédez à la console IAM. Dans la navigation de gauche, sélectionnez Rôles.

2. Sélectionnez Créer un nouveau rôle.

3. Sous Service AWS, sélectionnez la ligne AWS Lambda, puis Suivant : Permissions.

4. Sur l’écran Attach permissions policy (Attacher une politique de permissions), sélectionnez AWSLambdaRole. Vous pouvez utiliser le filtre fourni pour réduire la liste des options. Sélectionnez Next: (Suivant) Tags (Balises), puis sélectionnez Next:(Suivant) Review (Réviser) pour continuer.

5. Sur l’écran Review (Révision), indiquez un Role name (Nom de rôle), tel que Auth0Integration. Laissez les autres champs tels quels. Sélectionnez Create role (Créer le rôle).

6. Une fois qu’AWS a créé votre rôle, vous serez redirigé vers la page Roles (Rôles) d’IAM. Sélectionnez votre nouveau rôle.

7. Sur la page Résumé du rôle que vous venez de créer, sélectionnez la vue Relations de confiance.

8. Sélectionnez Edit trust relationship (Modifier la relation de confiance) et remplissez le champ Policy Document (Document de politique) avec l’extrait JSON suivant :

   {
   "Version": "2012-10-17",
   "Statement": [
       {
       "Effect": "Allow",
       "Principal": {
           "Service": [
           "apigateway.amazonaws.com",
           "lambda.amazonaws.com"
           ]
       },
       "Action": "sts:AssumeRole"
       }
   ]
   }

   Was this helpful?

   Yes /No

9. Cliquez sur Mettre à jour la politique de confiance.

10. Vous serez redirigé vers la page Résumé. Copiez la valeur Rôle ARN pour une utilisation ultérieure.

    

Maintenant que vous avez configuré votre autorisateur personnalisé pour votre environnement et que vous l’avez testé pour voir s’il fonctionne, déployez-le sur AWS.

1. Créez un paquet que vous pouvez télécharger sur AWS en exécutant npm run paquet. Cela génère un paquet custom-authorizer.zip contenant les modules source, de configuration et de nœud requis par AWS Lambda.

2. Naviguez jusqu’à la console Lambda et cliquez sur Create function (Créer une fonction).

3. Sur la page Sélectionner le modèle, cliquez sur Créer à partir de zéropour créer une fonction vierge. Sous Informations de base, indiquez les valeurs des paramètres suivants :

   Paramètre	Valeur
   Nom	Nom pour votre fonction Lambda, comme jwtRsaCustomAuthorizer
   Description	Description pour votre fonction Lambda (facultatif)
   Exécution	Sélectionnez Node.js 10.x

4. Cliquez sur Créer une fonction pour continuer.

5. Sur la page Configuration de votre fonction, descendez jusqu’à la section Function Code (Code de la fonction).

6. Sélectionnez Upload a .ZIP file (Télécharger un fichier .ZIP) comme Code entry type (Type d’entrée de code).

7. Cliquez sur Télécharger et sélectionnez le paquet custom-authorizer.zip que vous avez créé précédemment.

8. Créez ensuite les trois Variables d’environnement suivantes. Notez que ces informations sont identiques à celles du fichier .env.

   Parameter	Value
   TOKEN_ISSUER	L’émetteur du jeton. Si Auth0 est l’émetteur du jeton, utilisez https://{yourDomain}/
   JWKS_URI	L’URL du point de terminaison JWKS. Si Auth0 est l’émetteur du jeton, utilisez https://{yourDomain}/.well-known/jwks.json
   AUDIENCE	La valeur de l’identifiant de l’API qu vous créée à l’étape 1.

9. Dans la section Rôle d’exécution, sélectionnez Utiliser un rôle existant puis sélectionnez le rôle IAM que vous avez créé précédemment comme Rôle existant.

10. Sous Paramètres de base, définissez Temporisation sur 30 secondes.

11. Cliquez sur Enregistrer.

12. Pour tester la fonction Lambda que vous venez de créer, cliquez sur Test dans le coin supérieur droit.

13. Copiez le contenu de votre fichier event.json dans le formulaire Configure test event (Configurer l’événement de test). Vous pouvez utiliser le modèle d’événement par défaut « Hello World ».

14. Cliquez sur Créer.

15. Exécutez votre test en le sélectionnant et en cliquant sur Test. Si le test a réussi, vous verrez : « Résultat de l’exécution : succès ». L’agrandissement de la fenêtre de résultat devrait afficher un message similaire à celui que vous avez reçu après la réussite de votre test local.

    

1. Retournez à la console API Gateway (Passerelle API) et ouvrez l’API PetStore que nous avons créée plus tôt.

2. En utilisant la navigation de gauche, ouvrez Autorisateurs et sélectionnez Créer un nouvel autorisateur, puis définissez les paramètres suivants et cliquez sur Créer.

   Parameter	Value
   Name	jwt-rsa-custom-authorizer
   Type	Sélectionnez Lambda
   Lambda Region	Utiliser la région pour la fonction Lambda que vous avez créée précédemment
   Lambda Function	jwtRsaCustomAuthorizer
   Lambda Invoke Role	L’ARN du rôle IAM que vous avez copié ci-dessus
   Lambda Event Payload	Sélectionnez Token
   Token Source	Authorization
   Token Validation	^Bearer [-0-9a-zA-z\.]*$
   TTL (seconds)	3600

3. Une fois qu’AWS a créé l’autorisateur et que la page a été actualisée, testez votre autorisateur en cliquant sur Test et en fournissant le jeton Auth0 (Bearer ey...) que vous avez utilisé précédemment. Si le test a réussi, vous obtiendrez une réponse similaire à la suivante.

   

Pour savoir comment sécuriser les points de terminaison de votre API, consultez l’article du guide du développeur Amazon API Gateway (Passerelle API) : Utiliser des autorisateurs lambda de passerelle API.

1. Connectez-vous à AWS et accédez à la console Passerelle API.

   Les autorisations personnalisées sont définies méthode par méthode; si vous souhaitez sécuriser plusieurs méthodes à l’aide d’une autorisation unique, vous devrez répéter les instructions suivantes pour chaque méthode.

2. Ouvrez l’API PetStore que nous avons créée à l’étape 2 de ce tutoriel. Dans l’arborescence Resource (Ressource) du volet central, sélectionnez la méthode GET sous la ressource /pets.

   

3. Sélectionnez Requête de méthode.

4. Sous Settings (Réglages), cliquez sur l’icône crayon à droite de Authorization (Autorisation) et choisissez l’autorisateur personnalisé jwt-rsa-custom-authorizerl’étape 3.

5. Cliquez sur l’icône de crochet pour enregistrer votre choix d’autorisateur personnalisé. Assurez-vous que le champ API Key Required (Clé API requise) est défini sur false.

Pour rendre vos modifications publiques, déployez votre API.

1. Dans le menu Actions, sélectionnez Déployer API.

2. Indiquez les valeurs suivantes et cliquez sur Déployer :

   Paramètre	Valeur
   Étape de déploiement	Choisir [Nouvelle étape]
   Nom de l’étape	Indiquez un nom pour votre étape
   Description de l’étape	Décrivez votre étape
   Description du déploiement	Décrivez votre déploiement API

En cas de succès, vous serez redirigé vers l’éditeur de développement et de test Test Stage Editor. Notez l’Invoke URL fournie dans le ruban bleu en haut, car vous en avez besoin pour tester votre déploiement.

Pour tester votre déploiement, faites une requête GET au Invoke URL que vous avez notée à l’étape précédente. Si ce test échoue, vérifiez que vous avez obtenu correctement le jeton d’accès JWT.

Pour plus de détails, voir Obtenir des jetons d’accès.

curl --request GET \
  --url https://%7ByourInvokeUrl%7D/pets

var client = new RestClient("https://%7ByourInvokeUrl%7D/pets");
var request = new RestRequest(Method.GET);
IRestResponse response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io/ioutil"
)

func main() {

	url := "https://%7ByourInvokeUrl%7D/pets"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := ioutil.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

HttpResponse<String> response = Unirest.get("https://%7ByourInvokeUrl%7D/pets")
  .asString();

var axios = require("axios").default;

var options = {method: 'GET', url: 'https://%7ByourInvokeUrl%7D/pets'};

axios.request(options).then(function (response) {
  console.log(response.data);
}).catch(function (error) {
  console.error(error);
});

#import <Foundation/Foundation.h>

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"https://%7ByourInvokeUrl%7D/pets"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://%7ByourInvokeUrl%7D/pets",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

import http.client

conn = http.client.HTTPSConnection("")

conn.request("GET", "%7ByourInvokeUrl%7D/pets")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

require 'uri'
require 'net/http'
require 'openssl'

url = URI("https://%7ByourInvokeUrl%7D/pets")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "https://%7ByourInvokeUrl%7D/pets")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()