Share
Vad du ska skapaI november 2014 meddelade Digital Ocean sin nyligen uppgraderade DNS-värdtjänst. Förutom att vara snabb och pålitlig har användarna upplevt nära momentana uppdateringar av DNS-poster. Alla utvecklare eller systemadministratörer kan uppskatta fördelarna med detta: inte längre väntar på uppdateringar av IP-adresser under systemmigreringar. I denna handledning kommer vi att expandera funktionaliteten i den konsolansökan som vi byggt förra gången för att inkludera hantering av Digital Oceans DNS-tjänst.
Återigen kan du ladda ner gratis konsolprogrammet från Tuts + Github-arkivet. Jag har lagt fram en detaljerad installationsguide för konsolprogrammet på min hemsida. Du kan också utforska min generiska installationsguide för Digital Ocean-appar.
Medan du kan använda Digital Ocean webbkonsolen för att hantera dina DNS-poster, kan det hända att du är fördelaktig att programmässigt hantera dem via API: n.
Dokumentation för Digital Oceans DNS API-tjänster ligger på två huvudområden:
Vi fokuserar först när du konfigurerar dina domäner och sedan lägger till de enskilda DNS-posterna.
Innan du kan aktivera Digital Oceans egna DNS-tjänster måste du överföra dina domännamnservrar till Digital Ocean nameservers:
Jag ska lägga till min StarWars.io-domän för den här tutorial-demonstrationen. Här är mitt namn serverbyte hos min domänregistrator:
Du kan också hitta hur man pekar på DigitalOcean Nameservers from Common Domain Registrars som är till hjälp också.
Låt oss först lägga till en domän till Digital Ocean's DNS via sitt användargränssnitt. Längs navigeringsmenyn till vänster, klicka på DNS:
Klick Lägg till domän:
Så här visar Digital Ocean din DNS-post. Det är trevligt att det visar dig den genererade zonfilen nedan:
Därefter lägger vi till en domän En post för www.starwars.io:
Låt oss nu undersöka API: n, börja med att hämta några av domänerna och domänregistrerna som vi just skapat.
Låt oss först ladda ner listan över våra domäner med hjälp av API: n. Klicka på i vår konsolansökan domäner i navigeringsfältet och klicka på Synkronisera i den högra menyn.
De domänkontrollant kod ser så här ut:
allmän funktion actionSync () $ domain = new Domain (); $ Domän-> synk (); $ This-> omdirigera ( '/ domän / admin');
Domänmodellen kallar sedan våra Ocean-komponentfunktioner och lägger till varje domän som hittas i vår lokala databas:
synkronisering med offentlig funktion () $ ocean = new Ocean (); $ domäner = $ ocean-> getDomains (); foreach ($ domäner som $ d) $ domain_id = $ this-> add ($ d);
Här är API-koden från Ocean-komponenten för att hämta domänlistan:
allmän funktion getDomains () // returnera åtgärden api $ action = $ this-> digitalOcean-> domain (); // returnera en samling Action enhet $ actions = $ action-> getAll (); returnera $ actions;
Här är domänmodellen Lägg till metod:
Accentsconagua
public function add ($ domain) $ d = Domän :: modell () -> findByAttributes (array ('name' => $ domain-> namn)); om (tomt ($ d)) $ d = nytt domän; $ d-> name = $ domain-> namn; $ d-> ttl = $ domain-> ttl; $ d-> zone = $ domain-> zoneFile; $ d-> aktiv = 1; $ d-> created_at = $ d-> created_at; $ d-> modified_at = new CDbExpression ('NU ()'); $ D-> Spara (); returnera $ d-> id; Du borde se något så här efter det är klart:
Klicka på hantera ikonen i starwarsraden och du ser något så här:
Låt oss då synkronisera domänregistrerna för starwars.io. Klick Synkronisera Domain Records-detta kommer att ringa till SyncRecords handling i domänkontrollant:
public function actionSyncrecords ($ id) $ dr = new DomainRecord (); $ DR-> synk ($ id); $ This-> omdirigera ( '/ domän / vy /'.$ id);
De DomainRecord modell synkroniseringsmetod ser ut så här. Det gör en begäran om domännamnets poster och lägger till var och en till DomainRecord bord i vår lokala databas:
public function sync ($ id) // uppslag domän $ d = Domän :: modell () -> findByPk ($ id); $ ocean = new ocean (); $ records = $ ocean-> getDomainRecords ($ d-> namn); foreach ($ poster som $ r) $ record_id = $ this-> add ($ id, $ r);
Här är Ocean-komponenten getDomainRecords metod:
offentlig funktion getDomainRecords ($ name) $ action = $ this-> digitalOcean-> domainRecord (); $ actions = $ action-> getAll ($ namn); returnera $ actions;
De DomainRecord lägg till metod är lite mer detaljerad:
public function add ($ domain_id, $ record) $ dr = DomainRecord :: model () -> findByAttributes (array ('record_id' => $ record-> id)); om (tomt ($ dr)) $ dr = nytt domänrecord; $ dr-> domain_id = $ domain_id; $ dr-> record_id = $ record-> id; $ dr-> record_name = $ record-> namn; $ dr-> record_type = $ record-> typ; $ dr-> record_data = $ record-> data; om (isset ($ record-> prioritet)) $ dr-> priority = $ record-> prioritet; annars $ dr-> priority = null; om (isset ($ record-> port)) $ dr-> port = $ record-> port; annars $ dr-> port = null; om (isset ($ record-> weight)) $ dr-> vikt = $ record-> vikt; annars $ dr-> vikt = null; $ dr-> aktiv = 1; $ dr-> created_at = ny CDbExpression ('NU ()'); $ dr-> modified_at = ny CDbExpression ('NU ()'); $ DR-> Spara (); returnera $ dr-> id; Så här ser det ut när domänregistret synkroniserats:
Du kan också lägga till domäner och domänrecord från vår konsol manuellt.
Här är koden i domänmodellen som påminner API-förfrågan om att lägga till domänen:
allmän funktion remote_add () $ ocean = new Ocean (); $ domain = $ ocean-> createDomain ($ this-> namn, $ this-> ip_address); $ This-> save (); återvänd sant;
Här är Ocean-komponenten addDomain metod:
allmän funktion createDomain ($ name, $ ip_address) $ action = $ this-> digitalOcean-> domain (); $ create = $ action-> skapa ($ name, $ ip_address); returnera $ skapa;
Synkronisera sedan domänregistrerna och lägg till din egen:
Här är DomainRecord modell remote_add-metoden:
allmän funktion remote_add ($ id) $ d = Domän :: modell () -> findByPk ($ id); $ ocean = new ocean (); $ record = $ ocean-> createDomainRecord ($ d-> namn, $ this-> record_type, $ this-> record_name, $ this-> record_data, $ this-> prioritet, $ this-> port, $ this-> vikt ); $ this-> domain_id = $ id; $ this-> record_id = $ record-> id; $ this-> active = 1; $ this-> created_at = new CDbExpression ('NU ()'); $ this-> modified_at = new CDbExpression ('NU ()'); $ This-> save (); återvänd sant; Här är Ocean-komponenten createDomainRecord metod:
allmän funktion createDomainRecord ($ domain_name, $ type, $ namn, $ data, $ priority, $ port, $ weight) $ domainRecord = $ this-> digitalOcean-> domainRecord (); om ($ priority == ") $ priority = null; om ($ port ==") $ port = null; om ($ weight == ") $ weight = null; // returnera den skapade DomainRecord-enheten av domänen" bar.dk "$ created = $ domainRecord-> skapa ($ domain_name, $ type, $ name, $ data, $ prioritet, $ port, $ vikt), returnera $ skapad;
Du borde se något så här i vår konsol:
Här är vad Digital Ocean webbkonsol kommer att visa - märka hur vår lokala vy och fjärrvyn nu är identiska:
Som du kanske har märkt saknar denna kod robust felkontroll, synkronisering, uppdatering, radering och andra klockor och visselpipor. Jag lämnar det till dig för att förlänga som du önskar.
Jag hoppas att du har hittat denna undersökning av Digital Ocean DNS API för att vara till hjälp.
Var snäll och posta dina frågor och kommentarer nedan. Du kan också nå mig på Twitter @ reifman eller maila mig direkt. Följ min Tuts + instruktörssida för att se framtida artiklar om relaterade ämnen.
