> This page is for Camera to Cloud.
> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://next.developer.frame.io/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://next.developer.frame.io/_mcp/server.
# Procédure : Charger (de base)
## Introduction
Nous avons maintenant atteint une étape passionnante de notre parcours d'intégration : charger des asset vers Frame.io. Ce Guide vous accompagnera tout au long du processus de chargement de base.
## Conditions préalables
Si ce n'est pas déjà fait, veuillez consulter le Guide [Implémentation C2C : Configuration](./implementing-c2c-setting-up) avant de continuer. Vous aurez besoin du `access_token` obtenu pendant le [processus d'authentification et d'autorisation](./implementing-c2c-authentication-and-authorization). Pour ce Guide, nous utiliserons un asset test d'exemple disponible sur [ce lien Frame.io](https://f.io/Rq1q5CzB). Téléchargez ce fichier pour suivre nos exemples, car cela vous permettra de faire correspondre les valeurs de nos commandes d'exemple.
## Étape 1 : Créer un asset
Chargeons [notre fichier d'exemple](https://f.io/Rq1q5CzB), qui a été créé il y a 10 secondes selon nos hypothèses. Nous devons d'abord créer une référence d'asset dans Frame.io :
```shell
{
curl -X POST https://api.frame.io/v2/devices/assets \
--header 'Authorization: Bearer [access_token]' \
--header 'Content-Type: application/json' \
--header 'x-client-version: 2.0.0' \
--data-binary @- <<'__JSON__'
{
"name": "C2C_TEST_CLIP.mp4",
"filetype": "video/mp4",
"filesize": 21136250,
"offset": 10
}
__JSON__
} | python -m json.tool
```
La documentation pour `/v2/devices/assets` se [trouve ici](/camera-to-cloud/api-reference/device-asset-create). Bien que le point d'entrée hérité `/v2/assets` fonctionne encore, nous recommandons aux nouvelles intégrations d'utiliser `/v2/devices/assets`.
Contrairement aux points d'entrée d'authentification que nous avons utilisés précédemment, ce point d'entrée accepte l'encodage `application/json` plutôt que `form/multipart`. Il accepte également `application/x-www-form-urlencoded`.
Cet exemple utilise [heredoc](https://linuxize.com/post/bash-heredoc/) pour fournir la charge JSON à `curl` dans un format multiligne lisible. Le paramètre `--data-binary @-` indique à `curl` de lire les données brutes depuis stdin. En savoir plus sur cette approche [ici](https://unix.stackexchange.com/questions/88490/how-do-you-use-output-redirection-in-combination-with-here-documents-and-cat).
Examinons les paramètres de la charge JSON :
`name` : Le nom d'asset affiché dans Frame.io. Il n'est pas nécessaire que ceci corresponde au nom du fichier sur le disque. `filetype` : Le [type MIME](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Common_types) du fichier. La plupart des langages de programmation fournissent des utilitaires pour la détection du type MIME (exemples : [Go](https://golangcode.com/get-the-content-type-of-file/), [Python](https://docs.python.org/3/library/mimetypes.html)). `filesize` : La taille du fichier en octets. Notre fichier d'exemple fait environ 21,1 Mo. `offset` : Le nombre de secondes depuis la création du fichier. Par défaut à 0 si omis. Ce paramètre doit être fourni car il aide à déterminer si les fichiers doivent être rejetés en raison de la mise en pause de l'appareil. Nous couvrirons ceci plus en détail dans le [guide de chargement avancé](./how-to-advanced-uploads).
La réponse ressemblera à ceci (avec certains champs omis) :
```json
{
"_type": "file",
...
"id": "9a280f99-8f4f-46b0-a4b4-ec4c2f95138e",
...
"upload_urls": [
"https://frameio-uploads-production.s3-accelerate.amazonaws.com/parts/[part_01_path]",
"https://frameio-uploads-production.s3-accelerate.amazonaws.com/parts/[part_02_path]"
],
...
}
```
À ce stade, nous avons seulement informé Frame.io de notre intention de charger un fichier ; aucune donnée de fichier réelle n'a été transférée. Si vous vérifiez le dossier de votre appareil dans votre Projet, vous verrez un fichier d'espace réservé dans l'état « chargement en cours ».
Le champ `upload_urls` contient les URL où nous chargerons nos fragments de fichier. Pour notre fichier test, nous devrions recevoir deux URL de chargement.
## Étape 2 : Division du fichier en fragments
La réponse contenait plusieurs URL de chargement. Lors du chargement vers Frame.io, nous divisons les fichiers en fragments et les chargeons séparément, ce qui présente plusieurs avantages :
* **Fiabilité améliorée** : Si un fragment échoue, nous n'avons pas besoin de redémarrer tout le chargement
* **Chargements plus rapides** : Nous pouvons charger plusieurs fragments en parallèle (couvert dans le [guide de chargements avancés](./how-to-advanced-uploads))
Pour déterminer la taille de fragment optimale, utilisez cette formule :
**`Python`**
```python title="Python"
# We use math.ceil() to ensure we get the upper bound in the division
chunk_size = math.ceil(float(file.size) / float(len(response.upload_urls)))
```
Pour notre fichier d'exemple, le calcul est :
**`Python`**
```python title="Python"
math.ceil(21136250 / 2)
# 10568125
```
Cela signifie que chaque fragment devrait faire 10 568 125 octets. Les tailles de fragments ciblent généralement environ 25 Mo, avec les calculs exacts couverts dans le [guide de chargements avancés](./how-to-advanced-uploads).
Étant donné que les tailles de fichier se divisent rarement de manière égale, le dernier segment peut être plus petit que la `chunk_size` calculée.Votre implémentation doit en tenir compte lors de la lecture des segments de fichier.
Pour cette démonstration, nous utiliserons les commandes [HEAD](https://man7.org/linux/man-pages/man1/head.1.html) et [tail](https://man7.org/linux/man-pages/man1/tail.1.html) pour extraire les segments de fichier.
## Étape 3 : Chargement des segments
Pour charger le premier segment :
```shell
head -c 10568125 ~/Downloads/C2C_TEST_CLIP.mp4 | \
curl -X PUT https://frameio-uploads-production.s3-accelerate.amazonaws.com/parts/[part_01_path] \
--include \
--header 'content-type: video/mp4' \
--header 'x-amz-acl: private' \
--data-binary @-
```
Le paramètre `--data-binary @-` indique à `curl` d'utiliser des données brutes depuis stdin, qui proviennent de la commande `HEAD`.
La requête nécessite ces en-têtes :
`content-type` : La même valeur de type MIME utilisée lors de la création du fichier `x-amz-acl` : Pour les autorisations AWS S3, toujours défini sur `private`
Un chargement réussi renvoie :
```text
HTTP/1.1 100 Continue
HTTP/1.1 200 OK
...
```
De même, chargez le deuxième segment :
```shell
tail -c 10568125 ~/Downloads/C2C_TEST_CLIP.mp4 | \
curl -X PUT https://frameio-uploads-production.s3-accelerate.amazonaws.com/parts/[part_02_path] \
--include \
--header 'content-type: video/mp4' \
--header 'x-amz-acl: private' \
--data-binary @-
```
Une fois les deux chargements terminés, votre fichier devrait être lisible dans Frame.io !🎉
Lors du chargement de segments, vous envoyez des données directement à AWS S3, pas à l'API Frame.io.Les réponses d'erreur suivront les formats AWS S3 plutôt que les erreurs Frame.io standard.Nous aborderons la gestion des erreurs S3 dans le [Guide de gestion des erreurs](/camera-to-cloud/how-to-handle-errors).
Bien qu'il soit conceptuellement plus simple de charger les segments de manière séquentielle, ils peuvent en réalité être chargés dans n'importe quel ordre.Le système les assemblera correctement quelle que soit la séquence de chargement.
## Assemblage final
Voici un exemple simplifié de pseudocode Python pour le processus de chargement complet :
**`Python`**
```python title="Python"
file = open("~/Downloads/C2C_TEST_CLIP.mp4")
mimetype = mimetypes.for_file("~/Downloads/C2C_TEST_CLIP.mp4")[0]
created_at = time.ctime(file.stat.ST_CTIME)
asset = c2c.asset_create(
name="C2C_TEST_CLIP.mp4",
filetype=mimetype,
filesize=file.size,
offset=datetime.now() - created_at,
channel=0,
)
chunk_size = math.ceil(float(file.size) / float(len(asset.upload_urls)))
for chunk_url in asset.upload_urls:
chunk = file.read(bytes=chunk_size)
c2c.upload_chunk(chunk, chunk_url, mimetype)
```
Cet exemple démontre le flux de base sans gestion d'erreur ni chargements parallèles, qui seront abordés dans les guides [gestion des erreurs](/camera-to-cloud/how-to-handle-errors) et [chargements avancés](./how-to-advanced-uploads).
## Étapes suivantes
Félicitations pour avoir réussi à charger votre premier asset sur Frame.io !Le [Guide de chargement avancé](./how-to-advanced-uploads) couvrira des techniques plus sophistiquées et les exigences pour les implémentations prêtes pour la production.Nous vous encourageons à contacter notre équipe pour toute question et à consulter le [Guide de chargement en temps réel](./how-to-upload-realtime) pour apprendre à charger des asset pendant leur création.