Comment l’Open Source peut vous aider à gratter LinkedIn dans une base de données Postgres

Lancez la base de données Airflow en exécutant la commande suivante : airflow db init.

Créez un utilisateur pour Airflow à l’aide de la commande suivante tout en vous assurant de mettre à jour les valeurs requises avec les vôtres.

airflow users create     --username {YOUR_USERNAME}     --firstname {YOUR_NAME}     --lastname {YOUR_LAST_NAME}     --role Admin     --email {YOUR_EMAIL}

Une fois les packages installés, démarrez le serveur Web et le planificateur d’airflow en exécutant les commandes suivantes dans deux fenêtres de terminal distinctes. Assurez-vous que l’environnement virtuel est actif dans les deux fenêtres.

airflow webserver
airflow scheduler

Une fois la configuration terminée, visitez http://localhost:8080 pour accéder à l’interface utilisateur Web Airflow.

Saisissez les informations d’identification utilisées pour créer l’utilisateur à l’étape précédente. Une fois connecté, vous aurez accès à l’interface utilisateur d’Airflow comme indiqué ci-dessous.

Dans cette recette, le scraper Python analysera et traitera la page LinkedIn et stockera les données dans JSON à charger dans PostgreSQL. Il déclenchera ensuite une connexion Airbyte qui migrera les données récupérées de ce fichier vers une base de données PostgreSQL.

Configurez la source d’Airbyte en allant sur Connexions > nouvelle connexion.

Donnez un nom à la source et sélectionnez Type de Source comme Déposer puis Système de fichiers local sous fournisseur.

Ce fichier d’entrée requis par Airbyte doit être situé dans le chemin de montage de la machine locale physique suivant (/tmp/airbyte_local/) sur lequel Airbyte se monte ‘/local’. Dans cet exemple, nous avons créé un sous-répertoire sous ce chemin de montage physique appelé lié et un fichier JSON appelé linkedin.json.

L’URL logique effective que vous pouvez utiliser dans Airbyte est /local/linkedin/linkedin.json.

La configuration source devrait ressembler à ceci :

Une fois la source du fichier correctement configurée, la connexion peut être testée.

Étape 3 : Configuration de la base de données PostgreSQL

L’étape suivante consiste à configurer la destination des données grattées, dans ce cas, une base de données PostgreSQL. Si vous n’avez pas configuré PostgreSQL, vous pouvez rapidement en définir un avec docker en utilisant la commande suivante :

docker run --rm -P -p 127.0.0.1:5432:5432 -e POSTGRES_PASSWORD=password --name postgres postgres:alpine

Une fois que PostgreSQL est en cours d’exécution, vous aurez besoin d’une base de données créée qui sera utilisée par Airbyte pour écrire les données. Exécutez les commandes suivantes pour vous connecter à PostgreSQL et créer une nouvelle base de données appelée lié.

docker exec -ti postgres psql -U postgres
CREATE DATABASE linkedin;

Dans l’interface utilisateur d’Airbyte, sélectionnez PostgreSQL comme destination et entrez les valeurs suivantes pour votre configuration.

Avant de continuer, assurez-vous que la connexion est réussie.

Une fois la destination configurée, vous pouvez créer la connexion. Réglez la fréquence de synchronisation sur manuel et le mode de synchronisation à ajouter.

Une fois la connexion établie avec succès, notez l’ID de connexion, qui sera requis plus tard pour configurer Apache Airflow afin de déclencher cette connexion. L’ID se trouve dans l’URL de cette page de connexion.

L’étape suivante consiste à configurer Apache Airflow afin qu’il puisse déclencher les points de terminaison de l’API Airbyte.

Allez d’abord à Administrateur > Lien > Ajouter Lien.

Donnez un nom à l’ID de connexion (comme airbyte_linkedin_connection dans notre cas) et sélectionnez Airbyte comme type de connexion. Entrer hôte local pour hôte et 8001 pour le port. Appuyez sur Enregistrer.

Maintenant que la connexion Airflow pour déclencher Airbyte est configurée, nous devons créer un DAG dans Airflow qui, lors de l’exécution, exécutera notre scraper Python, stockera les données dans le fichier JSON, puis déclenchera la synchronisation Airbyte.

Créez un dossier dags et le fichier dag en exécutant les commandes suivantes dans votre terminal. Airflow récupérera automatiquement le dag créé dans le dossier au redémarrage.

cd airflow
mkdir dags && cd dags
touch airbyte_airflow_dag.py

Pour déterminer les profils Linkedin à gratter, le script a besoin d’un simple fichier CSV contenant les URL des profils requis, comme indiqué. Créez un fichier CSV avec les données suivantes sur votre ordinateur local. D’autres profils peuvent facilement être ajoutés au bas de ce fichier. Gardez une trace de l’emplacement de ce fichier car il est requis par le script Python.

person_id,profile_url 

1. https://www.linkedin.com/in/micheltricot/

2. https://www.linkedin.com/in/jean-lafleur-294083185/

3. https://www.linkedin.com/in/jrhizor/

Téléchargez le pilote Chrome et gardez une trace de son emplacement sur votre système de fichiers. Il s’agit d’un outil open source pour le test automatisé d’applications Web sur de nombreux navigateurs, et dans ce cas, nous l’utiliserons pour accéder à LinkedIn par programmation dans notre grattoir Web Python.

Copiez ensuite ce qui suit dans un fichier appelé airbyte_airflow_dag.py. Assurez-vous de mettre à jour les valeurs en surbrillance.

import requests
from bs4 import BeautifulSoup
import pandas as pd
import re
import os
from datetime import datetime

import json
from selenium import webdriver
from airflow import DAG
from airflow.utils.dates import days_ago
from airflow.providers.airbyte.operators.airbyte import AirbyteTriggerSyncOperator

with DAG(dag_id='trigger_linkedin_airbyte_job',
        default_args={'owner': 'admin'},
        schedule_interval="@daily",
        start_date=days_ago(1)
   ) as dag:

df=pd.read_csv('{PATH_TO}/profiles.csv')
driver = webdriver.Chrome('{PATH_TO}/chromedriver')

#login using webdriver
driver.get('https://www.linkedin.com/login?trk=guest_homepage-basic_nav-header-signin')
username = driver.find_element_by_id('username')
username.send_keys('{YOUR_LINKEDIN_USERNAME}')
password = driver.find_element_by_id('password')
password.send_keys('{YOUR_LINKEDIN_PASSWORD}')
sign_in_button = driver.find_element_by_xpath('//*[@type="submit"]')
sign_in_button.click()
Json_data = []
for i in range(df.shape[0]):

   URL = df['profile_url'][i] #change profile_url here
   driver.get(URL)

   soup = BeautifulSoup(driver.page_source, 'html.parser')
   person_id = df['person_id'][i]
   name = soup.find('div', {'class': 'display-flex justify-space-between pt2'}).find("h1").text.strip().encode('ascii', 'ignore').decode()

   position = soup.find('div', {'class': 'display-flex justify-space-between pt2'}).find('div', {'class': 'text-body-medium break-words'}).text.strip().encode('ascii', 'ignore').decode()
   location =soup.find('div', {'class': 'display-flex justify-space-between pt2'}).find('span', {'class': 'text-body-small inline t-black--light break-words'}).text.strip().encode('ascii', 'ignore').decode()
   company = soup.find('div', {'class': 'display-flex justify-space-between pt2'}).find('div', {'aria-label': 'Current company'}).text.strip().encode('ascii', 'ignore').decode()
   try:
       connec = soup.find('div', attrs={'class' : 'ph5'}).find('span', {'class': 'link-without-visited-state'}).text.strip().encode('ascii', 'ignore').decode()
   except:
       connec = soup.find('div', {'class': 'ph5 pb5'}).find('span', {'class': 't-bold'}).text.strip().encode('ascii', 'ignore').decode()
   no_conn=connec.split()[0]
   no_conn=no_conn[:3]
   no_conn=int(no_conn)

  user_data = dict()
  user_data['Person ID'] = str(person_id)
  user_data['Name'] = str(name)
  user_data['Role'] = str(position)
  user_data['Location'] = str(location)
  user_data['Current Company'] = str(company)
  user_data['Number of Connections'] = int(no_conn)
  json_data.append(user_data)

with open('/tmp/local_airbyte/linkedin/linkedin.json', 'w') as fp:
   json.dump(json_data, fp, sort_keys=True, indent=4)

   json_to_postgres = AirbyteTriggerSyncOperator(
       task_id='airbyte_airflow_linkedin',
       airbyte_conn_id='airbyte_linkedin_connection',
       connection_id='{YOUR_AIRBYTE_CONNECTION_ID}',
       asynchronous=False,
       timeout=3600,
       wait_seconds=3

Une fois le fichier enregistré, redémarrez le serveur Web et le planificateur Airflow, puis reconnectez-vous à l’interface utilisateur d’Airflow.

Une fois connecté, le DAG nouvellement ajouté doit être visible. Le DAG est programmé pour être exécuté une fois par jour mais peut également être déclenché manuellement.

Cliquez sur le DAG pour ouvrir la page DAG. Ici, activez le DAG et cliquez sur Bouton de lecture > Déclencher le DAG. Cela commencera le raclage de LinkedIn.

Pendant le grattage, le script écrira des données dans le /tmp/airbyte_local/linkedin/linkedin.json et devrait ressembler à quelque chose comme ça.

Une fois le grattage terminé, il déclenchera la synchronisation Airbyte.

Une fois la synchronisation terminée, vous pouvez vérifier que la tâche Airflow a été exécutée avec succès dans l’interface utilisateur.

Vous pouvez afficher les tables créées par Airbyte en exécutant les commandes suivantes :

docker exec -ti postgres psql -U postgres
c linkedin
dt

Vous pouvez afficher les données importées dans la table en exécutant la requête de table SQL suivante sur la table liée dans PostgreSQL

En interrogeant ces données, des campagnes marketing peuvent être exécutées pour sensibiliser à une nouvelle fonctionnalité de produit basée sur les intitulés de poste.

Voici ce que nous avons accompli au cours de cette recette :

• Configurer Apache Airflow
• Configurer la source de données JSON dans Airbyte
• Configurer une destination PostgreSQL Airbyte
• Créer et configurer le DAG dans Airflow
• Exécution de la synchronisation Airflow DAG et Airbyte
• Analyser les résultats

Ce n’était qu’un exemple de la façon dont Apache Airflow et Airbyte peuvent être utilisés pour créer des flux de travail robustes et complexes à l’aide d’outils open source.

Nous savons que les équipes de développement et d’exploitation travaillant sur des projets à évolution rapide avec des…