Dari Sifar ke Gabungan: Membina Komponen Medan Penamaan Semula JSON dalam Go

Pengenalan kepada Instill-ai

Mengusahakan projek hujung belakang saluran paip Instill adalah seperti menyelesaikan jigsaw ? teka-teki—kecuali beberapa kepingan terus bertukar nama! misi saya? Untuk mencipta komponen yang boleh menamakan semula medan JSON tanpa mencipta konflik. Sertai saya sambil saya berkongsi perjalanan saya melalui pembelajaran Go, mempelajari dokumen Instill yang teratur dan mencipta penyelesaian yang kini digabungkan dan sedia untuk dilancarkan! ?

---

Cabaran

Terapkan cara yang diperlukan untuk menamakan semula medan dalam struktur data JSON secara dinamik. Pusingan? Kami terpaksa mengendalikan kes di mana medan yang dinamakan semula mungkin bertembung dengan medan sedia ada. Tanpa sistem penyelesaian konflik, huru-hara akan bermaharajalela!

tanam-ai / saluran paip-belakang

⇋ Pelayan REST/gRPC untuk perkhidmatan Instill VDP API

hujung belakang saluran paip

pipeline-backend mengurus semua sumber saluran paip dalam Data Serbaguna Pipeline (VDP) untuk menyelaraskan data daripada komponen mula, melalui komponen AI/Data/Aplikasi dan hingga akhir komponen.

Konsep

Saluran Paip

Dalam ? Tanamkan VDP, saluran paip ialah DAG (Directed Acyclic Graph) yang terdiri daripada berbilang komponen.

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

Memuatkan

Komponen

Satu Komponen berfungsi sebagai blok bangunan penting dalam Saluran Paip.

Lihat dokumentasi pakej komponen untuk maklumat lanjut butiran.

Resipi

Satu resipi saluran paip menentukan cara komponen dikonfigurasikan dan cara ia saling berkaitan.

Resipi ditakrifkan dalam bahasa 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>

…

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?"

Gerade in diesem Moment stieß ich auf ein Fusselproblem—

Er wies auf das Problem hin und lieferte sogar die Lösung. Ich musste es nur implementieren, aber es war eine Erinnerung daran, dass selbst die kleinsten Details wichtig sind, damit der Code reibungslos funktioniert.

Sobald ich diese anfänglichen Hürden überwunden hatte, wurde das Testen zu meinem Sicherheitsnetz. Es gab mir die Gewissheit, dass mein Code in verschiedenen Szenarien funktionieren würde ?️‍♂️. Es hat mir auch gezeigt, dass das Testen nicht nur ein Schritt zum Abhaken ist, sondern eine Möglichkeit, sicherzustellen, dass mein Code zuverlässig und belastbar ist.

---

Schritt 5️⃣: CI-Prüfung und letzte Anpassungen

Nach Abschluss meiner Tests habe ich meinen Code gepusht, bereit für den Überprüfungsprozess. Unsere CI-Prüfungen (Continuous Integration) bestanden jedoch nicht. Annis Kommentar erinnerte mich sanft daran, meine Testfälle noch einmal zu überprüfen:

„Hey @AkashJana18, könntest du deine Testfälle überprüfen? Unser CI-Check zeigt, dass es hier nicht bestanden wurde. Bitte testen Sie es zuerst lokal, bevor Sie es an die PR weiterleiten. Wann immer Sie Ihren Commit vorantreiben, lösen wir die Prüfungen aus, damit Sie etwaige Probleme erkennen können, bevor unsere Ingenieure Ihren Code überprüfen. Danke!“

Da wurde mir klar, dass ich die Tests vor dem Absenden lokal ausführen musste. ChunHao fügte außerdem hinzu:

"Bitte führen Sie es aus und bestehen Sie es, bevor Sie die Überprüfung anfordern. Führen Sie $ go test ./pkg/component/operator/json/v0/... aus, um es lokal zu überprüfen."

Ich habe die Tests schnell vor Ort durchgeführt, die Probleme identifiziert und behoben.

Ein kleiner Moment des Feierns?

Durch diesen Prozess wurde mir noch mehr bewusst, wie wichtig lokale Tests sind, da dadurch sichergestellt wurde, dass alles solide war, bevor ich es zur Überprüfung einreichte.

Vor der Zusammenführung führte ChunHao eine abschließende Überprüfung durch, nahm ein paar Optimierungen vor, überprüfte das Testrezept und aktualisierte die Dokumentation, um die neuen Änderungen widerzuspiegeln. Vielen Dank an Anni für ihre kontinuierliche Unterstützung während des gesamten Prozesses – es hat einen großen Unterschied gemacht. ?

---

? Réflexion sur le processus collaboratif ???‍???

L'une des plus grandes leçons que j'ai apprises était de savoir comment la collaboration et le mentorat peuvent faire ou défaire un projet. Les modérateurs d'Instill, Anni et ChunHao, m'ont fourni les conseils dont j'avais besoin lorsque j'étais perdu dans la syntaxe Go ou que j'avais du mal à trouver la bonne approche. En travaillant ensemble, nous avons transformé un problème complexe en une solution propre et fonctionnelle.

Je vais être honnête, il y a eu des moments où j’ai eu l’impression d’avoir mordu plus que je ne pouvais mâcher. Mais les encouragements constants d'Anni, combinés aux instructions claires de ChunHao, m'ont permis de rester sur la bonne voie.

---

⏭️ Prochaines étapes et améliorations futures

Une autre étape pourrait consister à étendre cette approche à d'autres parties du pipeline qui nécessitent une gestion dynamique des noms de champs, car qui n'aime pas un peu d'automatisation⚙️ ?

---

?️ Outils et ressources ?

1. Documentation Go : pour plonger dans la syntaxe Go et comprendre les concepts de base.
2. Instill Docs : une mine d'or de ressources bien organisées pour comprendre le pipeline Instill.
3. Go Testing Framework : le package de tests intégré à Go pour écrire des tests unitaires, garantir que tout fonctionne comme prévu et s'intégrer aux outils CI.
4. Golangci-lint : un agrégateur Go linters pour identifier les problèmes et garantir la qualité du code pendant le développement et les vérifications CI.

---

???‍???️ Mon apprentissage

Grâce à la documentation solide d'Instill, aux conseils de ChunHao et au soutien moral d'Anni, ce projet est devenu une fantastique expérience d'apprentissage. Je suis passé de ne rien savoir de Go à l'implémentation d'une fonctionnalité entièrement fonctionnelle prête pour la production (et j'ai le PR fusionné pour le prouver ?).

Preuve :

Atas ialah kandungan terperinci Dari Sifar ke Gabungan: Membina Komponen Medan Penamaan Semula JSON dalam Go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!