Coiled

Coiled est un service cloud qui permet, entre autres, de déployer des clusters Dask en quelques clics. Il est particulièrement adapté pour les utilisateurs de Jupyter et de pandas.

Lien entre Dask et Coiled

Dask a été créé par Matthew Rocklin qui est lui-même CEO de Coiled.

Démarrage rapide

• Créer un compte gratuit sur Coiled et s'y connecter.
• Aller sur le get started et suivre les instructions.
• Pour la suite, on suppose que Coiled installé dans l'environnement virtuel et qu'on est connecté coiled login.
• Lancer un Hello world sur une VM avec cette commande coiled run echo "Hello, world"

Quelques exemples

Traitement des données NASA earthdata

Cet exemple pris du site de Coiled permet de montrer comment déléguer des traitement sur le Cloud. En effet, le décorateur @coiled.function permet de lancer une fonction sur un cluster Dask Coiled. Il est possible de spécifier le nombre de workers, la mémoire, etc.

Concrètement, cet exemple, traiter 500Go de données de façon distribuée sur le Cloud et affiche ensuite le résultat sous forme d'un graphique en local.

• Créer un compte urs.earthdata.nasa.gov
• Véerifier qu'on est bien connecté à Coiled avec la commande coiled login

• Installer les dépendances suivantes dans l'environnement virtuel :

  pip install coiled earthaccess xarray numpy matplotlib netcdf4 h5netcdf
  

• Lancer le script suivant :

  # Source: https://coiled.io/example/nasa-cloud-datasets
  
  import coiled
  import os
  import tempfile
  import earthaccess
  import numpy as np
  import xarray as xr
  import matplotlib.pyplot as plt
  
  # Create a free NASA Earthdata account (https://urs.earthdata.nasa.gov/)
  try:
      earthaccess.login()
  except:
      print("login failed")
      exit(1)
  
  # Step 2: Find the dataset files we want to analyze
  granules = earthaccess.search_data(
      short_name="MUR-JPL-L4-GLOB-v4.1",  # Sea Surface Temperature dataset
      temporal=("2020-01-01", "2021-12-31"),  # Two years of data
  )
  
  # Delete processing to coiled
  
  
  @coiled.function(
      region="us-west-2",                  # Run in the same region as data
      environ=earthaccess.auth_environ(),  # Forward Earthdata auth to cloud VMs
      spot_policy="spot_with_fallback",    # Use spot instances when available
      arm=True,                            # Use ARM-based instances
      cpu=1,                               # Use single-core instances
  )
  def process(granule):
      """Process a single data granule to extract Great Lakes temperature data"""
      results = []
      with tempfile.TemporaryDirectory() as tmpdir:
          files = earthaccess.download(granule, tmpdir)
          for file in files:
              ds = xr.open_dataset(os.path.join(tmpdir, file))
              # Select Great Lakes region by longitude/latitude
              ds = ds.sel(lon=slice(-93, -76), lat=slice(41, 49))
              # Filter for water temperature (exclude ice-covered areas)
              cond = (ds.sea_ice_fraction < 0.15) | np.isnan(ds.sea_ice_fraction)
              result = ds.analysed_sst.where(cond)
              results.append(result)
      return xr.concat(results, dim="time")
  
  
  # Step 4: Run processing across all files in parallel
  results = process.map(granules)
  
  # Step 5: Combine results and visualize
  ds = xr.concat(results, dim="time")
  
  # Calculate temperature standard deviation across time
  plt.figure(figsize=(14, 6))
  std_temp = ds.std("time")
  std_temp.plot(x="lon", y="lat", cmap="viridis")
  plt.title("Standard Deviation of Sea Surface Temperature (2020-2021)")
  plt.xlabel("Longitude")
  plt.ylabel("Latitude")
  plt.savefig("great_lakes_sst_variation.png")
  plt.show()
  

Traitement des données Uber et Lyft

A priori, il faut lier son compte à AWS pour accéder au dataset.

import coiled
import dask.dataframe as dd

cluster = coiled.Cluster(n_workers=10)
client = cluster.get_client()
print(client)

# Load the Uber-Lyft Taxi dataset from s3 (200 GB)
df = dd.read_parquet("s3://coiled-data/uber/")
# How often do New Yorkers tip?
(df.tips != 0).mean().compute()

Notebooks sur le cloud

Les notebooks Coiled sont un moyen pratique pour exécuter des notebooks Jupyter sur le cloud. Ils sont basés sur JupyterLab et permettent de faire tout ce qu'on peut faire en local mais avec la puissance de calcul du cloud. On peut meême utiliser PyPark après avoir installé Java (par exemple un conda install openjdk=21) et la librairie pyspark avec un pip install pyspark.