Aanpassen van Go Binaries met Build Tags

Introductie

In Go, een build tag, ofwel een build-constraint, is een identifier die aan een stuk code wordt toegevoegd en bepaalt wanneer het bestand moet worden opgenomen in een pakket tijdens het build-proces. Dit stelt u in staat om verschillende versies van uw Go-applicatie te bouwen vanuit dezelfde broncode en snel en georganiseerd tussen hen te schakelen. Veel ontwikkelaars gebruiken build tags om de workflow van het bouwen van cross-platform compatibele applicaties te verbeteren, zoals programma’s die codewijzigingen vereisen om variaties tussen verschillende besturingssystemen te compenseren. Build tags worden ook gebruikt voor integratietesten, zodat u snel kunt schakelen tussen de geïntegreerde code en de code met een mock service of stub, evenals voor verschillende niveaus van functie sets binnen een applicatie.

Laat ons het probleem van verschillende klantfunctie sets als voorbeeld nemen. Bij het schrijven van sommige toepassingen wil je mogelijk controleren welke functies je wilt opnemen in de binarie, zoals een toepassing die Gratis, Pro en Enterprise niveaus aanbiedt. Als de klant hun abonnementsniveau in deze toepassingen verhoogt, worden er meer functies ontgrendeld en beschikbaar. Om dit probleem op te lossen, kun je afzonderlijke projecten onderhouden en proberen ze met elkaar in sync te houden via het gebruik van import-verklaringen. Hoewel deze aanpak zou werken, zou het na verloop van tijd vervelend en foutgevoelig worden. Een alternatieve aanpak zou zijn om build tags te gebruiken.

In dit artikel zul je build tags in Go gebruiken om verschillende uitvoerbare binariën te genereren die de Gratis, Pro en Enterprise functie sets van een voorbeeldtoepassing aanbieden. Elk zal een andere set functies beschikbaar hebben, met de Gratis versie als standaard.

Voorvereisten

Om het voorbeeld in dit artikel te volgen, heb je nodig:

• Een Go-werkruimte ingesteld door Hoe Go installeren en een lokale programmeeromgeving inrichten te volgen.

Bouwen aan de gratis versie

Laten we beginnen met het bouwen van de gratis versie van de applicatie, omdat dit de standaard zal zijn wanneer u go build uitvoert zonder enige bouw tag. Later gebruiken we bouw tags om selectief andere onderdelen toe te voegen aan onze programma.

In de src directory, maak een map met de naam van uw applicatie. Deze tutorial gebruikt app:

mkdir app

Geef de map een naam:

cd app

Mover je naar deze map:

nano main.go

Maak nu een nieuwe tekstbestand in je gewezen teksteditor genaamd main.go:

package main

import "fmt"

var features = []string{
  "Free Feature #1",
  "Free Feature #2",
}

func main() {
  for _, f := range features {
    fmt.Println(">", f)
  }
}

Nu gaan we definieren wat de gratis versie van de applicatie is. Voeg de volgende inhoud toe aan main.go:In deze bestand, hebben we een variabeel features gedefinieerd die twee string’s bevat dat representeren de functies van onze gratis applicatie. De main() functie in de applicatie gebruikt een for-loop om door de features slice te range en alle beschikbare functies op de scherm te printen.

Naar het Nederlands vertalen:

Sla de bestand op en sluit het af. Nu dat dit bestand is geopend, hoeven we er voor de rest van de artikelen niet meer aan te werken. In plaats daarvan gebruiken we bouw tags om de eigenschappen van de binaries te wijzigen die we uit deze bestand gaan bouwen.

Bouwen en uitvoeren van de programma:

go build
./app

U bent de volgende output te krijgen:

Output
> Free Feature #1
> Free Feature #2

Het programma heeft de twee gratis functies geprinted, waarmee de gratis versie van onze app is voltooid.

Tot nu toe heb je een applicatie gemaakt met een zeer basiselijke functieset. Nu zullen jij een manier maken om meer functies toe te voegen aan de applicatie tijdens de bouwstap.

Met go build de Pro-functies Toevoegen

Zoals we tot nu toe hebben vermijden om main.go te editeren, simuleren we hier een gebruikersomgeving waarin code moet worden toegevoegd zonder de hoofdcode te breken. Zoals we de main.go-bestand niet kunnen bijwerken, gebruiken we een andere methode om meer functies toe te voegen aan de features-slice met help van bouw tags.

Maak een nieuwe bestand genaamd pro.go dat gebruik maakt van een init() functie om meer functies aan de features-slice toe te voegen:

nano pro.go

Zodra de editor deze bestand heeft opengesteld, voeg de volgende lijnen toe:

package main

func init() {
  features = append(features,
    "Pro Feature #1",
    "Pro Feature #2",
  )
}

In deze code hebben we init() gebruikt om code uit te voeren voordat de main()-functie van onze applicatie wordt aangeroepen, gevolgd door append() om de Pro-functies toe te voegen aan de features-slice. Sla het bestand op en sluit het.

Compileer en voer de applicatie uit met behulp van go build:

go build

Aangezien er nu twee bestanden in ons huidige directory zijn (pro.go en main.go), zal go build een binair bestand maken van beide. Voer dit binaire bestand uit:

./app

Dit geeft je de volgende functie-set:

Output
> Free Feature #1
> Free Feature #2
> Pro Feature #1
> Pro Feature #2

De applicatie bevat nu zowel de Pro- als de Free-functies. Dit is echter niet wenselijk: aangezien er geen onderscheid is tussen versies, bevat de Free-versie nu de functies die alleen beschikbaar zouden moeten zijn in de Pro-versie. Om dit op te lossen, kun je meer code toevoegen om de verschillende niveaus van de applicatie te beheren, of je kunt build tags gebruiken om de Go-toolchain te vertellen welke .go-bestanden moeten worden gebuild en welke moeten worden genegeerd. Laten we in de volgende stap build tags toevoegen.

Build Tags Toevoegen

Je kunt nu build tags gebruiken om de Pro-versie van je applicatie te onderscheiden van de Free-versie.

Laten we beginnen door te kijken hoe een build tag eruitziet:

// +build tag_name

Door deze regel code als eerste regel van je pakket in te voegen en tag_name te vervangen door de naam van je build tag, markeer je dit pakket als code die selectief kan worden opgenomen in de uiteindelijke binair bestand. Laten we dit in actie zien door een build tag toe te voegen aan het pro.go bestand om het go build commando te vertellen het te negeren, tenzij de tag is gespecificeerd. Open het bestand in je teksteditor:

nano pro.go

Voeg vervolgens de volgende highlighted regel toe:

// +build pro

package main

func init() {
  features = append(features,
    "Pro Feature #1",
    "Pro Feature #2",
  )
}

Aan de top van het pro.go bestand hebben we // +build pro toegevoegd, gevolgd door een lege nieuwe regel. Deze volgende nieuwe regel is vereist, anders interpreteert Go dit als een commentaar. Build tag declaraties moeten ook helemaal bovenaan een .go bestand staan. Niets, zelfs geen commentaren, kunnen boven build tags staan.

De +build declaratie vertelt het go build commando dat dit geen commentaar is, maar in plaats daarvan een build tag. Het tweede deel is de pro tag. Door deze tag bovenaan het pro.go bestand toe te voegen, zal het go build commando nu alleen het pro.go bestand opnemen als de pro tag aanwezig is.

Compileer en voer de applicatie opnieuw uit:

go build
./app

Je ontvangt de volgende uitvoer:

Output
> Free Feature #1
> Free Feature #2

Aangezien het pro.go bestand vereist dat een pro tag aanwezig is, wordt het bestand genegeerd en compileert de applicatie zonder het.

Wanneer je het go build commando uitvoert, kun je de -tags vlag gebruiken om conditioneel code op te nemen in de gecompileerde bron door de tag zelf als argument toe te voegen. Laten we dit doen voor de pro tag:

go build -tags pro

Dit zal de volgende uitvoer geven:

Output
> Free Feature #1
> Free Feature #2
> Pro Feature #1
> Pro Feature #2

Nu krijgen we de extra functionaliteiten alleen als we de applicatie bouwen met de pro build tag.

Dit is in orde als er maar twee versies zijn, maar dingen worden compliceerder als je meer tags toevoegt. Om in de volgende stap de Enterprise versie van onze app toe te voegen, zullen we meerdere build tags met elkaar verbinden met behulp van Booleaanse logica.

Build Tag Booleaanse Logica

Wanneer er meerdere build tags zijn in een Go-pakket, interageren de tags met elkaar met behulp van Booleaanse logica. Om dit te demonstreren, zal het Enterprise niveau van onze applicatie worden toegevoegd met behulp van zowel de pro tag als de enterprise tag.

Om een Enterprise-binair bestand te maken, moeten we zowel de standaard functionaliteiten, de functionaliteiten van het Pro-niveau en een nieuw stel functionaliteiten voor Enterprise bijvoegen. Open eerst een editor en maak een nieuw bestand aan, enterprise.go, dat de nieuwe Enterprise-functionaliteiten zal toevoegen:

nano enterprise.go

De inhoud van enterprise.go zal bijna identiek zijn aan pro.go maar zal nieuwe functionaliteiten bevatten. Voeg de volgende regels toe aan het bestand:

package main

func init() {
  features = append(features,
    "Enterprise Feature #1",
    "Enterprise Feature #2",
  )
}

Sla het bestand op en sluit het bestand af.

Het huidige enterprise.go-bestand heeft geen bouwlabels, en zoals je leerde toen je pro.go toevoegde, betekent dit dat deze functies worden toegevoegd aan de Gratis versie bij het uitvoeren van go.build. Voor pro.go heb je // +build pro en een nieuwe regel toegevoegd bovenaan het bestand om go build te vertellen dat het alleen moet worden ingesloten wanneer -tags pro wordt gebruikt. In deze situatie heb je slechts één bouwlabel nodig om het doel te bereiken. Bij het toevoegen van de nieuwe Enterprise-functies, moet je echter eerst ook de Pro-functies hebben.

Laten we eerst ondersteuning voor het pro-bouwlabel toevoegen aan enterprise.go. Open het bestand met je teksteditor:

nano enterprise.go

Voeg vervolgens het bouwlabel toe voor de package main-verklaring en zorg ervoor dat je een nieuwe regel invoegt na het bouwlabel:

// +build pro

package main

func init() {
  features = append(features,
    "Enterprise Feature #1",
    "Enterprise Feature #2",
  )
}

Bewaar en sluit het bestand.

Compileer en voer de applicatie uit zonder labels:

go build
./app

Je ontvangt de volgende uitvoer:

Output
> Free Feature #1
> Free Feature #2

De Enterprise-functies verschijnen niet langer in de Gratis versie. Laten we nu het pro-bouwlabel toevoegen en de applicatie opnieuw bouwen en uitvoeren:

go build -tags pro
./app

Je ontvangt de volgende uitvoer:

Output
> Free Feature #1
> Free Feature #2
> Enterprise Feature #1
> Enterprise Feature #2
> Pro Feature #1
> Pro Feature #2

Dit is nog steeds niet precies wat we nodig hebben: De Enterprise-functies verschijnen nu wanneer we proberen de Pro-versie te bouwen. Om dit op te lossen, hebben we een ander bouwlabel nodig. In tegenstelling tot het pro-label, moeten we er nu voor zorgen dat zowel de pro– als de enterprise-functies beschikbaar zijn.

Het bouwsysteem van Go rekent met deze situatie door het gebruik van enkele basis Boolean logica in het systeem van bouwlabels toe te staan.

Open weer enterprise.go:

nano enterprise.go

Voeg een andere bouwtag toe, enterprise, op dezelfde regel als de pro tag:

// +build pro enterprise

package main

func init() {
  features = append(features,
    "Enterprise Feature #1",
    "Enterprise Feature #2",
  )
}

Sla op en sluit de bestanden af.

Compileer nu de applicatie met de nieuwe enterprise bouwtag en voer deze uit.

go build -tags enterprise
./app

Dit zal de volgende output geven:

Output
> Free Feature #1
> Free Feature #2
> Enterprise Feature #1
> Enterprise Feature #2

We hebben nu de Pro-functies verloren. Dat is omdat we bij het plaatsen van meerdere bouwtags op dezelfde regel in een .go-bestand, go build ze als een OF-logica interpreteert. Met de toevoeging van de regel // +build pro enterprise, zal het bestand enterprise.go worden gebouwd alservan of de pro bouwtag of de enterprise bouwtag aanwezig is. We moeten de bouwtags correct instellen om beide te vereisen en in plaats daarvan AND-logica te gebruiken.

In plaats van beide tags op dezelfde regel te plaatsen, als we ze op aparte regels plaatsen, zal go build deze tags als AND-logica interpreteren.

Open enterprise.go opnieuw en verdeel de bouwtags over meerdere regels.

// +build pro
// +build enterprise

package main

func init() {
  features = append(features,
    "Enterprise Feature #1",
    "Enterprise Feature #2",
  )
}

Compileer nu de applicatie met de nieuwe enterprise bouwtag en voer deze uit.

go build -tags enterprise
./app

U krijgt de volgende output:

Output
> Free Feature #1
> Free Feature #2

Nog niet helemaal daar: omdat een AND-uitspraak beide elementen moet beschouwen als true, moeten we beide bouwtags pro en enterprise gebruiken.

Probeer we nog eens:

go build -tags "enterprise pro"
./app

Je ontvangt de volgende uitvoer:

Output
> Free Feature #1
> Free Feature #2
> Enterprise Feature #1
> Enterprise Feature #2
> Pro Feature #1
> Pro Feature #2

Nu kan onze applicatie vanuit dezelfde broncodeboom op meerdere manieren worden gebouwd, waarbij de functies van de applicatie dienovereenkomstig worden geactiveerd.

In dit voorbeeld hebben we een nieuwe // +build-tag gebruikt om EN-logica te weergeven, maar er zijn alternatieve manieren om Booleaanse logica met build-tags voor te stellen. De volgende tabel bevat enkele voorbeelden van andere syntactische opmaak voor build-tags, samen met hun Booleaanse equivalent:

Conclusie

In deze handleiding heb je build-tags gebruikt om te bepalen welke code van je wordt gecompileerd naar de binary. Eerst heb je build-tags gedeclareerd en gebruikt met go build, vervolgens heb je meerdere tags gecombineerd met Booleaanse logica. Vervolgens heb je een programma gebouwd dat de verschillende functie sets van een Free, Pro en Enterprise versie weergeeft, wat laat zien hoe krachtig de controle is die build-tags je kunnen geven over je project.

Als je meer wilt weten over build-tags, kijk dan naar de Golang documentatie over dit onderwerp, of continue met het verkennen van onze How To Code in Go series.