demander des données Google Analytics à partir d'un serveur local

Question

Je souhaite écrire un script PHP qui importe les données de statistiques Web de GA. Le script est accessible via un frontal Web (pour déclencher l'importation) et réside sur un serveur local (127.0.0.1).

Comme je l'ai compris de la documentation est qu'il ya deux options pour l'authentification et en utilisant l'API de base:

1. API clés - subventions que l'accès aux statistiques
2. OAuth2 - autorisation complète

Si je comprends correctement la mécanique de OAuth2, ce n'est pas une option dans mon scénario car je ne peux pas spécifier une URL de rappel. Les solutions Hacky me viennent à l'esprit - comme l'établissement d'une authentification de profil Web se connectant directement à GA à partir du navigateur puis en récupérant les données par JavaScript et en les injectant dans le script d'importation - mais je préfère éviter de telles solutions. En outre, l'interaction du navigateur déclenchant le processus d'importation peut être remplacée par un travail cron dans le futur.

La clé API semble être exactement ce que je veux, mais la requête GET du navigateur échoue.

requête GET:

https://www.googleapis.com/analytics/v3/data/ga 
    ?ids=ga:[profile ID] 
    &start-date=2013-01-01&end-date=2013-01-05 
    &metrics=ga:visits 
    &key=[the API key] 

Réponse:

{ 
    error: { 
    errors: [ 
    { 
     domain: "global", 
     reason: "required", 
     message: "Login Required", 
     locationType: "header", 
     location: "Authorization" 
    } 
    ], 
    code: 401, 
    message: "Login Required" 
    } 
} 

L'URL bien devrait être bien. Excepté le paramètre clé, il est le même que celui généré avec http://ga-dev-tools.appspot.com/explorer/ qui fonctionne également (AOuth2 est utilisé dans ce cas). La clé API est fraîche.

Puis générer à nouveau une nouvelle clé API me confronte à l'inconvénient suivant qui est que, apparemment, la clé n'est valide que pour un jour.

---

Ainsi, à la fin de la journée ma question est la suivante:

Est-il possible de récupérer les données dans le scénario décrit ci-dessus sans avoir à authentifier manuellement ou générer des clés de l'API sur une base quotidienne?

Answer 1

Comme nous l'avons suggéré, utilisez cette bibliothèque: https://code.google.com/p/google-api-php-client/ mais, au lieu d'utiliser OAuth, créez un compte de la console api (il suffit de sélectionner l'application serveur) de service . Cela vous fournira un identifiant de client, un email identifiant le compte de service et un fichier * .p12 contenant la clé privée.

Vous devez ensuite ajouter le compte de service (l'e-mail) à vos analyses en tant qu'administrateur afin d'obtenir les données dont vous avez besoin.

Pour utiliser le service:

$client = new Google_Client(); 
$client->setApplicationName('test'); 

$client->setAssertionCredentials(
    new Google_AssertionCredentials(
     EMAIL, 
     array('https://www.googleapis.com/auth/analytics.readonly'), 
     file_get_contents(PRIVATE_KEY_FILEPATH) 
    ) 
); 
$client->setClientId(CLIENT_ID); 
$client->setAccessType('offline_access'); 

$analytics = new Google_AnalyticsService($client); 

Pour obtenir des données:

$analytics->data_ga->get(PROFILE_ID, $date_from, $date_to, $metrics, $optParams) 

Pour les détails docs vérifier api. En outre, soyez prudent, il y a un plafond de requête (sauf si vous payez)

Answer 2

Je pense que pour que cela fonctionne, vous devez utiliser OAuth mais avec une légère modification pour l'exécuter à partir du serveur. Google appelle cette méthode d'authentification "Using OAuth 2.0 for Web Server Applications"

Comme décrit sur cette page, vous pouvez utiliser une bibliothèque client PHP pour obtenir l'authentification. La bibliothèque client est située here.

Un exemple d'utilisation de cette bibliothèque client se trouve sur le help pages du même projet. Notez que vous devrez apporter quelques modifications au code comme le disent les commentaires pour stocker le jeton dans db et le rafraîchir régulièrement.

<?php 
require_once 'google-api-php-client/src/Google_Client.php'; 
require_once 'google-api-php-client/src/contrib/Google_PlusService.php'; 

// Set your cached access token. Remember to replace $_SESSION with a 
// real database or memcached. 
session_start(); 

$client = new Google_Client(); 
$client->setApplicationName('Google+ PHP Starter Application'); 
// Visit https://code.google.com/apis/console?api=plus to generate your 
// client id, client secret, and to register your redirect uri. 
$client->setClientId('insert_your_oauth2_client_id'); 
$client->setClientSecret('insert_your_oauth2_client_secret'); 
$client->setRedirectUri('insert_your_oauth2_redirect_uri'); 
$client->setDeveloperKey('insert_your_simple_api_key'); 
$plus = new Google_PlusService($client); 

if (isset($_GET['code'])) { 
    $client->authenticate(); 
    $_SESSION['token'] = $client->getAccessToken(); 
    $redirect = 'http://' . $_SERVER['HTTP_HOST'] . $_SERVER['PHP_SELF']; 
    header('Location: ' . filter_var($redirect, FILTER_SANITIZE_URL)); 
} 

if (isset($_SESSION['token'])) { 
    $client->setAccessToken($_SESSION['token']); 
} 

if ($client->getAccessToken()) { 
    $activities = $plus->activities->listActivities('me', 'public'); 
    print 'Your Activities: <pre>' . print_r($activities, true) . '</pre>'; 

    // We're not done yet. Remember to update the cached access token. 
    // Remember to replace $_SESSION with a real database or memcached. 
    $_SESSION['token'] = $client->getAccessToken(); 
} else { 
    $authUrl = $client->createAuthUrl(); 
    print "<a href='$authUrl'>Connect Me!</a>"; 
} 

Answer 3

J'ai une configuration similaire.La chose que vous ne réalisez pas est que vous pouvez spécifier un http://localhost ou http://127.0.0.1 ou n'importe quoi d'autre comme origine et URL de rappel. Vous devez configurer une interface Web sur votre serveur local qui initie une configuration OAuth pour l'utilisateur avec l'accès GA. Notez que c'est une fois. Le gestionnaire de rappel doit ressembler à ceci:

Remarque: Les bibliothèques utilisées ici sont identiques à la réponse précédente, le code détaillé se trouve dans l'encapsuleur.

$redirect = 'http://' . $_SERVER['HTTP_HOST'] . '/content/business-intelligence'; 
if (isset($_GET['code'])) { 
    require_once 'GAPI.php'; 
    $client = GAPI::init(); //create client instance of Google_Client 
    $client->authenticate(); //convert auth code to access token 
    $token = $client->getAccessToken(); 
    $retVal = CF_GAPI::persistToken($token); //save token 
    if($retVal) 
     $redirect .= "?new_token"; 
    else 
     $redirect .= "?bad_token"; 
} 
header('Location: ' . $redirect); //redirect to bi index 

Une fois que vous avez enregistré le jeton enregistré, vous devez définir dans le client avant de faire des demandes de GA pour obtenir vos données d'analyse. Comme:

try { 
    $token = GAPI::readToken(); //read from persistent storage 
} catch (Exception $e) { 
    $token = FALSE; 
} 

if($token == FALSE) { 
    $logger->crit("Token not set before running cron!"); 
    echo "Error: Token not set before running cron!"; 
    exit; 
} 

$client = GAPI::init(); //instance of Google_Client 
$client->setAccessToken($token); 

Le GAPI::init() est mis en œuvre comme suit:

$client = new Google_Client(); 
$client->setApplicationName(self::APP_NAME); 

$client->setClientId(self::CLIENT_ID); 
$client->setClientSecret(self::CLIENT_SECRET); 
$client->setRedirectUri(self::REDIRECT_URI); 
$client->setDeveloperKey(self::DEVELOPER_KEY); 

//to specify that the token is stored offline 
$client->setAccessType('offline'); 

//all results will be objects 
$client->setUseObjects(true); 

//tell that this app will RO from Analytics 
$client->setScopes('https://www.googleapis.com/auth/analytics.readonly'); 

return $client; 

Ma table MySQL a des colonnes comme id, title, send_to_emails, frequency, dimensions, metrics, filters, profile_id qui définissent complètement chaque rapport généré à partir de GA. Vous pouvez jouer avec eux en utilisant le documentation, et le sandbox tester que vous connaissez déjà.