De zéro à la fusion : création d'un composant de champ de renommage JSON dans Go

Introduction à Instill-ai

Travailler sur le projet pipeline-backend d'Instill, c'était comme résoudre un puzzle ? puzzle, sauf que certaines pièces changeaient de nom ! Ma mission ? Créer un composant capable de renommer les champs JSON sans créer de conflits. Rejoignez-moi pour partager mon parcours d'apprentissage de Go, d'étude des documents bien organisés d'Instill et de création d'une solution désormais fusionnée et prête à fonctionner ! ?

---

Le défi

Instill avait besoin d'un moyen de renommer dynamiquement les champs dans les structures de données JSON. Le rebondissement ? Nous avons dû gérer des cas où un champ renommé pouvait entrer en conflit avec un champ existant. Sans un système de résolution des conflits, le chaos règnerait en maître !

instiller-ai / backend de pipeline

⇋ Un serveur REST/gRPC pour le service API Instill VDP

pipeline-backend

pipeline-backend gère toutes les ressources de pipeline dans Versatile Data Pipeline (VDP) pour rationaliser les données du composant de début, en passant par les composants AI/Données/Application et jusqu'à la fin composant.

Concepts

Pipeline

Dans ? Instill VDP, un pipeline est un DAG (Directed Acyclic Graph) constitué de plusieurs composants.

flowchart LR
s[Trigger] --> c1[OpenAI Component]
c1 --> c2[Stability AI Component]
c1 --> c3[MySQL Component]
c1 --> e[Response]
c2 --> e

Chargement

Composant

Un Composant sert d'élément de base essentiel au sein d'un Pipeline.

Voir la documentation du package de composants pour en savoir plus détails.

Recette

Une recette de pipeline précise comment les composants sont configurés et comment ils sont interconnectés.

Les recettes sont définies en langage YAML :

variable
  <span># pipeline input fields</span>
output:
  <span># pipeline output fields</span>
component:
  <component-id>:
    type: <component-definition-id>
    task: <task-id>
    input:
      <span># values for the input fields</span>
    condition: <condition> <span># conditional statement to execute or bypass the</span>

…

Voir sur GitHub

To be honest, I was starting to doubt if I could solve this issue, but then Anni dropped the perfect message that kept me going.

Once I got comfortable, ChunHao, who had crafted a JSON schema for this task, gave me the green light? to start coding. And so, the journey began!

---

Step 2️⃣: Designing the Solution

The key requirements were:

1. Dynamic Renaming: Fields should be renamed without disturbing the JSON structure.
2. Conflict Detection: We needed to spot any conflicts between the original and renamed fields.
3. Conflict Resolution: A smooth solution, like appending a suffix, would prevent name clashes.

---

Step 3️⃣: Building the Component

Armed with coffee☕ and courage?, I got down to coding. Here’s a sneak peek at the core logic:

Mapping Fields

First, I created a mapping system to track old and new field names. This was key to detecting conflicts.

func mapFields(fields map[string]string) map[string]string {
    newFieldMap := make(map[string]string)
    for oldName, newName := range fields {
        // Check for conflict
        if _, exists := newFieldMap[newName]; exists {
            newName += "_conflict" // Add suffix for conflicts
        }
        newFieldMap[oldName] = newName
    }
    return newFieldMap
}

Any time a conflict was detected, the function added "_conflict" to the new name. It’s a simple trick that ensures our JSON fields stay unique and, most importantly, friendly to each other! ✌️

Renaming Fields

Once the field mappings were in place, the next step was applying them to our JSON data.

func renameFields(data map[string]interface{}, fieldMap map[string]string) map[string]interface{} {
    renamedData := make(map[string]interface{})
    for key, value := range data {
        newKey := fieldMap[key]
        renamedData[newKey] = value
    }
    return renamedData
}

Here’s the logic that applies the mapped names to our JSON data. The result? Our data’s neatly renamed, conflicts resolved, and structure intact. ?

After creating the component dropped the draft PR & got a comment:

---

Step 4️⃣: Testing and Refinement

After familiarizing myself with Instill's testing methods and learning how to create effective test cases, I proceeded further.

Testing time! ? I wrote tests covering everything from simple renames to complex edge cases with nested JSON fields. Each round of testing led to further refinements.

{
    name: "ok - rename fields with overwrite conflict resolution",
    // Test where renaming conflicts are resolved by overwriting the existing field.
    // Expected outcome: "newField" holds "value1", overwriting any previous value.
},

{
    name: "ok - rename fields with skip conflict resolution",
    // Test where conflicts are resolved by skipping the rename if the target field already exists.
    // Expected outcome: "newField" remains "value2" without overwrite.
},

{
    name: "nok - rename fields with error conflict resolution",
    // Test with "error" strategy, which should raise an error on conflict.
    // Expected outcome: Error message "Field conflict."
},

// Additional cases for missing required fields and invalid conflict resolution strategy

Here’s where I’d love to share a personal reflection: Testing was the hardest part of this project ?‍?. There were times when I thought, "Is this test even doing what it’s supposed to?"

就在那時，我遇到了lint問題—

他指出了問題，甚至提供了解決方案。我所要做的就是實現它，但這提醒我，即使是最小的細節也能讓程式碼順利運行。

一旦我克服了最初的障礙，測試就成了我的安全網。它讓我有信心知道我的程式碼可以在不同的場景下運作？ ️‍♂️。它還向我表明，測試不僅僅是一個檢查步驟，它是確保我的程式碼可靠且有彈性的一種方法。

---

步驟5️⃣步：CI檢查和最終調整

完成測試後，我推送了程式碼，準備進行審核過程。然而，我們的 CI（持續整合）檢查沒有通過。 Anni 的評論溫柔地提醒我仔細檢查我的測試案例：

「嘿@AkashJana18，你能檢查一下你的測試案例嗎？我們的CI 檢查顯示這裡還沒有通過。請先在本地進行測試，然後再推送到PR。每當您推送提交時，我們都會觸發檢查，以便您可以在我們的工程師審查您的程式碼之前發現任何問題。

那時我意識到我必須在提交之前在本地運行測試。春浩也補充：

「請在請求審核之前執行並通過。執行 $ go test ./pkg/component/operator/json/v0/... 在本機檢查。」

我快速在本地運行測試，發現問題並修復它們。

慶祝一下？
這個過程讓我更加體會到本地測試的重要性，因為它確保了在提交審核之前一切都是可靠的。

合併之前，ChunHao 進行了最終審查，進行了一些調整，對測試配方進行了 QA 並更新了文件以反映新的更改。非常感謝安妮在整個過程中持續提供的支持——這帶來了巨大的改變。 ？

---

? Reflexion über den kollaborativen Prozess ???

Eine der größten Lektionen, die ich gelernt habe, war, wie Zusammenarbeit und Mentoring ein Projekt über Erfolg oder Misserfolg entscheiden können. Die Moderatoren von Instill, Anni und ChunHao, gaben mir die Anleitung, die ich brauchte, wenn ich mich in der Go-Syntax verloren hatte oder Probleme mit dem richtigen Ansatz hatte. Gemeinsam haben wir aus einem komplexen Problem eine saubere, funktionale Lösung gemacht.

Ich bin ehrlich, es gab Momente, in denen ich das Gefühl hatte, ich hätte mehr abgebissen, als ich ertragen konnte. Aber die ständige Ermutigung von Anni, gepaart mit der klaren Anweisung von ChunHao, hielten mich auf dem Laufenden.

---

⏭️ Nächste Schritte und zukünftige Verbesserungen

Ein weiterer Schritt könnte darin bestehen, diesen Ansatz auf andere Teile der Pipeline auszuweiten, die eine dynamische Verarbeitung von Feldnamen erfordern – denn wer liebt nicht ein bisschen Automatisierung⚙️?

---

?️ Tools & Ressourcen ?

1. Go-Dokumentation: Zum Eintauchen in die Go-Syntax und zum Verständnis der Kernkonzepte.
2. Instill-Dokumente: Eine Goldgrube gut organisierter Ressourcen zum Verständnis der Instill-Pipeline.
3. Go Testing Framework: Das integrierte Testpaket in Go zum Schreiben von Unit-Tests, um sicherzustellen, dass alles wie erwartet funktioniert, und für die Integration mit CI-Tools.
4. Golangci-lint: Ein Go-Linters-Aggregator zur Identifizierung von Problemen und zur Durchsetzung der Codequalität während der Entwicklung und CI-Prüfungen.

---

??‍???️ Mein Lernen

Mit Instills fundierter Dokumentation, der Anleitung von ChunHao und Annis moralischer Unterstützung wurde dieses Projekt zu einer fantastischen Lernerfahrung. Ich wusste nichts über Go, sondern implementierte ein voll funktionsfähiges Feature, das für die Produktion bereit ist (und ich habe die zusammengeführte PR, um das zu beweisen?).

Beweis:

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!