De vez en cuando tengo la suerte de poder publicar publicaciones invitadas Por personas ilustres en las industrias de análisis y advertising digital. Esta vez, me toca trabajar con un viejo colega mío que es un verdadero mago cuando se trata de crear soluciones que hacen que nuestro trabajo diario en la industria digital sea mucho más fluido.
Erik Grönroos trabaja como analista en Academia Markkinointiuna agencia finlandesa de adquisición de clientes digitales. El trabajo de Erik es utilizar datos y análisis para ayudar a hacer crecer la agencia y las empresas de los clientes con los que trabaja.
En esta guía, Erik compartirá contigo cómo crear una aplicación que te ayude a automatizar el monitoreo de tu Anuncios de Google cuentas que utilizan el Lenguaje de programación Rel API de AdWords y el API de Slack.
Me entusiasma especialmente publicar este artículo, ya que es la primera vez (si recuerdo correctamente) que Google Advertisements y R se tratan en el weblog.
De todos modos, como editor, todos los errores y equivocaciones que puedas encontrar en el artículo son 100% correctos. mea culpaasí que déjenme saber en los comentarios si los errores persistieron hasta el borrador last. ¡Gracias!
X
El boletín informativo de Simmer
Suscríbete a la Boletín informativo de Simmer ¡Para recibir las últimas noticias y contenidos de Simo Ahava en tu bandeja de entrada de correo electrónico!
Introducción
En este artículo te mostraré cómo implementar un Aplicación de monitoreo automatizado para controlar sus cuentas de Google Advertisements. Dado que la naturaleza de la implementación es una prueba de concepto (PoC), intentaré simplificarla utilizando solo un caso de uso práctico para demostrar el proceso de un extremo a otro:
Detección sin costo en cuentas de anuncios, para monitorear vencimientos de tarjetas de crédito u otros problemas que impidan que sus anuncios se publiquen.
Esta implementación utiliza R y el API de Google AdWords para comprobar los datos, API de Slack para recibir alertas en tiempo actual a través de su bot de Slack si se detecta algo crítico, y el buen y viejo… cron para programar el guión.
Si eres una agencia de advertising, una situación típica es que tienes muchas cuentas de Google Advertisements de las que ocuparte. Cuando la cantidad de cuentas supera los cientos o miles, gestionarlas, supervisarlas y mantenerlas manualmente ya no es una opción.
Lo que puedes hacer, por supuesto, es configurar Google Advertisements. alertas incorporadas una por una para cada una de tus cuentas. Incluso puedes gestionar estas alertas a través de la API de anuncios de Google o utilizar Scripts de Google AdvertisementsPero el problema con estos es que incluyen alertas por correo electrónico de manera predeterminada. Estamos en 2019. El correo electrónico probablemente no sea el único canal que deberías usar para la automatización de edificios.
Entonces decidimos aprovechar la fuerza de las API y, como resultado, ¡salvamos la galaxia!
Cómo funciona la solución
El script se rellena con la lista de ID de cuenta de Google Advertisements Queremos monitorear. El sistema de monitoreo en sí mismo consulta el datos de costos de cada ID utilizando el API de Google AdWordsy analiza los resultados de aquellas cuentas que no han acumulado ningún costo, lo que señala posibles problemas con sus presupuestos o sus configuraciones.
Una vez analizada esta información, los ID de cuenta que se marcaron se escriben en un base de datos para su posterior análisis y se envía una notificación al Bot de Slack para que el equipo responsable pueda ser notificado inmediatamente cuando surjan problemas.
Requisitos
Acerca de R
R es un lenguaje de programación estadística que hoy en día admite prácticamente los mismos trucos de aprendizaje automático (ML) que Python. R vs. Python es un debate de larga knowledge, por lo que en realidad se cut back a la preferencia de lenguaje: ¡cuál quieres usar para cosas interesantes sobre datos! Bueno, me volveré a poner los pantalones, espera un momento.
No necesitamos ML en este ejemplo de monitoreo easy, pero sí lo usamos para soluciones más avanzadas. Por eso, R es la herramienta que elegimos.
RStudio es un IDE para R que facilita su uso. Cita del sitio internet de RStudio:
RStudio es un entorno de desarrollo integrado (IDE) para R. Incluye una consola, un editor de resaltado de sintaxis que admite la ejecución directa de código, así como herramientas para trazar, historial, depuración y gestión del espacio de trabajo.
RStudio está disponible en ediciones comerciales y de código abierto y se ejecuta en el escritorio (Home windows, Mac y Linux) o en un navegador conectado a RStudio Server o RStudio Server Professional (Debian/Ubuntu, RedHat/CentOS y SUSE Linux).
Si aún no tienes RStudio instalado, obtén el tuyo desde Descargas de RStudio.
En este artículo no entraremos en detalles sobre la instalación de RStudio. El sitio internet de RStudio ofrece documentación completa y procedimientos paso a paso para ello.
Una vez que tengas tu RStudio configurado y funcionando, ¡comencemos a escribir el script!
Episodio I: Un guión R
Estamos usando MariaDB para almacenar los ID de cliente de Google Advertisements de nuestros clientes, de donde se pueden recuperar para varios otros fines de integración y automatización que necesitamos.
Si utiliza otro servidor de base de datos, deberá modificar la parte de la base de datos del código para adaptarla a sus necesidades. R ofrece compatibilidad completa con una amplia variedad de bases de datos, tal vez incluso con todas ellas. Básicamente, si se trata de algo relacionado con datos, R puede leerlos.
Si no utiliza una base de datos, puede omitir la parte de la base de datos. Opcionalmente, R también puede leer los identificadores, por ejemplo, de Google Sheets o de un archivo CSV. ¡Cómo hacer esto en R es su tarea!
Probablemente estés pensando: “Pero ¿por qué no estás leyendo los ID directamente desde la API de AdWords”?
Bueno, lo lamentable es que palabras claveel paquete R AdWords, implementa únicamente el Servicio de informes de la API de Adwords, y el Servicio de informes no admite la consulta de los ID de clientes de Google Advertisements en el nivel de cuenta de administrador (anteriormente conocido como Mi centro de clientes o Centro de management de Google). En cambio, necesitaría acceso al servicio de atención al cliente administrado por la API de AdWords para hacerlo.
En nuestro caso, esto no es un problema, ya que queremos conservar los identificadores en nuestro propio entorno personalizado y tener diferentes clasificaciones y niveles para distintos tipos de contratos y clientes. De esta manera, podemos realizar las acciones deseadas para aquellos clientes que las necesitan y también podemos agregar capacidades de monitoreo a la configuración.
Si necesita leer los ID directamente desde la API de AdWords, puede acceder al Servicio de atención al cliente administrado a través de un paquete R más nuevo llamado adwordsR.
¡Ahora, escribamos un guión actual!
Cree un nuevo archivo R en su RStudio con el siguiente contenido, configure su usuario y contraseña de base de datos y guarde el archivo como db_credentials.R en /YOUR_R_USER_ROOT_DIR/auth/Este es su archivo de autenticación de base de datos.
db_username = "YOUR_USERNAME"
db_password = "YOUR_PASSWORD"Cree otro archivo que incluya el siguiente código y guarde el archivo como connect_db.R en /YOUR_R_USER_ROOT_DIR/Este es su conector DB.
# Embody DB credentials out of your /auth/ dir
supply("~/auth/db_credentials.R")
# Examine if the required packages are put in, set up if not
if(!require(DBI)) set up.packages("DBI")
if(!require(RMariaDB)) set up.packages("RMariaDB")
# Load packages
library(DBI)
library(RMariaDB)
# Create a DB connection deal with
con <- dbConnect(
drv = RMariaDB::MariaDB(),
username = db_username,
password = db_password,
host = "YOUR_DB_HOST",
port = 3306,
"YOUR_DB_NAME"
)Y finalmente el script de Advertisements R actual, incluye el siguiente código y guárdalo como google-ads-zero-cost-monitor.R en /YOUR_R_USER_ROOT_DIR/.
# Init the DB connection
supply("~/connect_db.R")
# Examine if the required packages are put in, set up if not
if(!require(RAdwords)) set up.packages("RAdwords")
# Load packages
library(RAdwords)
# Outline the file path the place your AdWords API OAuth RData file ought to be saved to, we'll want this subsequent
google_ads_auth_file <- "~/auth/google_ads_auth.RData"
# Examine if the google_auth RData file already exists, create if not
if(!file.exists(google_ads_auth_file)) {
# Auth steps:
# 1) You may want Google API Shopper ID, Shopper Secret and AdWords Developer Token right here for authenticating, see https://github.com/jburkhardt/RAdwords for particulars
# 2) As soon as you have supplied these in your R console when R requests them, you may get redirected to OAuth display in your browser
# 3) Authenticate along with your Google Account (the identical that has entry to your AdWords account)
# 4) You may be redirected to a OAuth success display that gives a last token code and asks you to repeat/paste it to your utility (to your R console on this case)
google_auth <- doAuth(save = FALSE)
# Save the auth credentials, for use the auth from a file to any extent further
save(google_auth, file = google_ads_auth_file)
}
# Load Google auth credentials
load(file = google_ads_auth_file)
# Init date vars
dayBeforeYesterday <- Sys.Date() - 2
yesterday <- Sys.Date() - 1
# Fetch Google Advertisements Buyer IDs out of your DB
ads_accounts <- dbGetQuery(con, "SELECT ads_customer_id FROM ads_accounts")
# Create an inventory of the IDs for later looping
account_list <- ads_accounts$ads_customer_id
# Alternatively, if you wish to skip the DB stuff, you possibly can outline your Google Advertisements Buyer IDs manually by uncommenting the next line and itemizing the IDs right here:
# account_list <- c("123-123-1234", "234-234-2345")
# Init AdWords API request
# We're checking the fee knowledge from two earlier days
physique <- assertion(choose = c('Value'),
report = "ACCOUNT_PERFORMANCE_REPORT",
begin = dayBeforeYesterday,
finish = yesterday)
# Init a knowledge body for accumulating the information and and an index variable for protecting observe of progressing in the course of the for loop
adsdata <- knowledge.body()
progressIndex <- 0
# Get the Advertisements price knowledge
for (account in account_list) {
# Get price knowledge
ads_api_response <- getData(clientCustomerId = account,
google_auth = google_auth,
assertion = physique)
# Proceed provided that the API does not return an error (occurs when there is not any knowledge to return or when the API fails), that is for dropping off false zero price alerts
if(!is.null(dim(ads_api_response))) {
# Init empty knowledge body
adsdata_temp <- setNames(knowledge.body(matrix(ncol = 2, nrow = 1)), c("Value", "Account"))
# Embody account id
adsdata_temp$Account <- account
# Embody price knowledge
# If there is not any knowledge, the result's doubled for some purpose
# Repair this by all the time studying the first worth solely with (1)
adsdata_temp$Value <- ads_api_response$Value(1)
# If price is zero, NA is returned, exchange it with zero
if(is.na(adsdata_temp$Value)) adsdata_temp$Value <- 0
# Gather throughout every iteration
adsdata <- rbind(adsdata, adsdata_temp, stringsAsFactors = FALSE)
}
# Print progress to R console
progressIndex <- progressIndex + 1
cat(paste("Question ", progressIndex, " of ", NROW(account_list), " donern", sep = ""))
}
# Hold accounts with zero price solely
ads_accounts_with_zero_cost <- subset(adsdata, Value == 0)
# Rely nbr of alerted accounts
nbr_of_accounts_with_alerts <- nrow(ads_accounts_with_zero_cost)
# Save all alerts to DB, if there was any
# This assumes you've gotten DB desk named "alerts" present with fields:
# ads_customer_id VARCHAR
# class VARCHAR
# status_id INT
# created_at DATETIME
# updated_at DATETIME
if(nbr_of_accounts_with_alerts > 0) {
for (i in 1:nrow(ads_accounts_with_zero_cost)) {
row <- ads_accounts_with_zero_cost(i, )
ads_customer_id <- row$ads_customer_id
class <- "ALERT_ZERO_COST" # For categorizing several types of alerts
status_id <- 0 # To be set to eg. 1 when the alert is dealt with by way of a customized UI
# Save every merchandise to db
question <- paste("INSERT INTO alerts (
ads_customer_id,
class,
status_id,
created_at,
updated_at)
VALUES (",
"'", ads_customer_id, "', ",
"'", class, "', ",
status_id, ", ",
"now(), ",
"now())",
sep = ""
)
dbExecute(con, question)
}
# If you wish to examine/debug what was saved, uncomment and run these strains
# db_alerts <- dbGetQuery(con, "SELECT * FROM alerts")
# View(db_alerts)
}Ahora tienes listo el script de monitorización de anuncios sin coste y puedes continuar con la configuración de tu bot de Slack.
Episodio II: El bot de Slack contraataca
Como los chicos de Slack son geniales, han escrito una guía excelente sobre cómo configurar tu bot. ¡Incluso te sirven galletas virtuales! Las guías de Slack son un ejemplo clásico sobre cómo debe redactarse la documentación. ¡Siempre es un placer leerlas y seguirlas! ¡Gracias, chicos!
Así que, sigue las Guía de usuarios de bots de SlackLos pasos necesarios para nuestras notificaciones de alerta son:
-
Crea tu aplicación Slack
-
Crea tu usuario bot
-
Instala tu bot en tu espacio de trabajo de Slack
Una vez que logres instalar tu bot en tu espacio de trabajo de Slack, recibirás un URL del webhook que necesitarás en el siguiente script.
La parte del script del bot está aquí:
### SLACK NOTIFICATIONS ###
# Exchange the default worth with the webhook URL you bought from Slack
webhook_url <- "https://hooks.slack.com/companies/12345"
# Examine if the required packages are put in, set up if not
if(!require(jsonlite)) set up.packages("jsonlite")
if(!require(httr)) set up.packages("httr")
# Load packages
library(jsonlite)
library(httr)
# Nbr of accounts for the Slack notification
nbr_of_accounts <- NROW(account_list)
# Setup the message you need to ship to Slack
msg_desc <- paste("Variety of Google Advertisements accounts checked: ",
nbr_of_accounts,
sep = "")
msg_title <- paste("ALERT - Variety of zero price accounts detected: ",
nbr_of_accounts_with_alerts,
sep = "")
# This locations a channel ping if there have been occurrences with zero price, and if not, defaults to empty message
if(nbr_of_accounts_with_alerts > 0) {
msg_body <- "Alerts saved to database! "
} else {
msg_body <- ""
}
# Alert to Slack - POST the msg
request <- POST(webhook_url,
physique = paste(
'{"attachments": ({',
'"title": "',
msg_title,
'",',
'"pretext": "',
msg_desc,
'",',
'"textual content": "',
msg_body,
'", "shade": "#ee0000"',
'})}',
sep = ''
)
)Una vez que hayas configurado esto, incluye la parte de Slack anterior en tu script google-ads-zero-cost-monitor.R. ¡Tu script de monitoreo ya está listo!
Así es como se vería una notificación de muestra en Slack:
Pruébelo cuidadosamente en su RStudio y asegúrese de que todo esté funcionando correctamente. Después de eso, estará listo para mover su script a producción programándolo a través de cron.
Episodio III: El regreso del trabajo cron
Abierto crontab en su shell de Linux para editar:
Agregue un trabajo cron que se adapte a sus necesidades. Aquí se muestra un ejemplo de sintaxis con un programador que ejecuta el script de monitoreo de R todos los días a las 10 a. m.
# Every day at 10 AM
0 10 * * * Rscript /residence/YOUR_USERNAME/google-ads-zero-cost-monitor.RResumen
Ahora ha creado un canal de monitorización de Google Advertisements potencialmente potente que tiene infinitas oportunidades de ampliación. Otros casos de uso útiles para utilizar el canal son, por ejemplo, la detección de anomalías, el seguimiento de gastos elevados, las tareas a nivel de campaña, la automatización de la optimización de la ubicación de los anuncios, and so on.
No hace falta decir que la automatización es absolutamente necesaria en estos tiempos, ya que puede ahorrarle a usted y a su equipo incontables horas de trabajo guide. Al automatizar procesos triviales como el monitoreo y la detección de anomalías, está liberando a sus recursos más valiosos (personas) para que trabajen en tareas más ambiciosas.
Como siempre, esperamos sus comentarios y preguntas. ¡Díganos qué piensa de la solución, si se podría mejorar y si ya tiene extensiones en mente!