Share
Wat je gaat creërenIn november 2014 kondigde Digital Ocean zijn onlangs bijgewerkte DNS-hostingservice aan. Naast het feit dat ze snel en betrouwbaar zijn, hebben gebruikers vrijwel onmiddellijke updates van DNS-records meegemaakt. Elke ontwikkelaar of systeembeheerder kan de voordelen hiervan waarderen: niet langer wachten op updates van IP-adressen tijdens systeemmigraties. In deze zelfstudie gaan we de functionaliteit van de consoletoepassing die we de vorige keer hebben gebouwd uitbreiden met het beheer van de DNS-service van Digital Ocean.
Nogmaals, je kunt de gratis consoletoepassing downloaden van de Tuts + Github-repository. Ik heb een gedetailleerde installatiehandleiding voor de consoletoepassing op mijn website geplaatst. U kunt ook mijn generieke installatiehandleiding voor Digital Ocean-apps verkennen.
Hoewel u de Digital Ocean-webconsole kunt gebruiken om uw DNS-records te beheren, is het misschien voordelig om ze via de API programmatisch te beheren..
Documentatie voor de DNS API-services van Digital Ocean bevindt zich op twee hoofdgebieden:
We richten ons eerst op het configureren van uw domeinen en vervolgens op het toevoegen van de afzonderlijke DNS-records.
Voordat u Digital Ocean's eigen DNS-services kunt activeren, moet u uw domeinnaamservers overdragen naar de Digital Ocean-naamservers:
Ik ga mijn StarWars.io-domein toevoegen voor deze zelfstudiedemonstratie. Hier is mijn naamserverwijziging bij mijn domeinregistrar:
Mogelijk vindt u ook Nuttige referentiepunten voor DigitalOcean-Nameservers van Common Domain Registrars nuttig.
Laten we eerst een domein toevoegen aan Digital Ocean's DNS via de webgebruikersinterface. Klik in het navigatiemenu links op DNS:
Klik Voeg domein toe:
Hier leest u hoe Digital Ocean uw DNS-record weergeeft. Het is leuk dat je hieronder het gegenereerde zonebestand ziet:
Vervolgens voegen we een domein A-record toe voor www.starwars.io:
Laten we nu de API verkennen, beginnend met het downloaden van enkele van de domeinen en domeinrecords die we zojuist hebben gemaakt.
Laten we eerst de lijst met onze domeinen downloaden met behulp van de API. Klik in onze console-applicatie op domeinen in de navigatiebalk en klik op Synchroniseren in het rechter menu.
De Domein controller code ziet er als volgt uit:
public function actionSync () $ domain = new Domain (); $ Domein-> sync (); $ This-> redirect ( '/ domein / admin');
Het domeinmodel roept vervolgens onze oceaancomponentfuncties en voegt elk gevonden domein toe aan onze lokale database:
sync met openbare functies () $ ocean = new Ocean (); $ domains = $ ocean-> getDomains (); foreach ($ domeinen als $ d) $ domain_id = $ this-> add ($ d);
Hier is de API-code van de component Ocean om de domeinlijst op te halen:
openbare functie getDomains () // retourneer de actie api $ action = $ this-> digitalOcean-> domain (); // stuur een verzameling Action entity $ actions = $ action-> getAll () terug; return $ acties;
Dit is de methode voor het toevoegen van een Domain-model:
Accentsconagua
public function add ($ domain) $ d = Domain :: model () -> findByAttributes (array ('name' => $ domain-> name)); if (leeg ($ d)) $ d = nieuw domein; $ d-> naam = $ domein-> naam; $ d-> ttl = $ domein-> ttl; $ d-> zone = $ domein-> zoneFile; $ d-> actief = 1; $ d-> created_at = $ d-> created_at; $ d-> modified_at = nieuwe CDbExpression ('NU ()'); $ D-> save (); return $ d-> id; Je zou zoiets moeten zien nadat het voltooid is:
Klik op de beheer pictogram in de rij van starwars en je ziet zoiets als dit:
Laten we vervolgens de domeinrecords voor starwars.io synchroniseren. Klik Synchroniseer domeinrecords-dit zal de SyncRecords actie in Domein controller:
public function actionSyncrecords ($ id) $ dr = nieuwe DomainRecord (); $ DR-> sync ($ id); $ This-> redirect ( '/ domain / view /'.$ id);
De DomainRecord model sync-methode ziet er als volgt uit. Het maakt een aanvraag voor de records van de domeinnaam en voegt deze toe aan de DomainRecord tabel in onze lokale database:
sync met openbare functie ($ id) // zoekdomein $ d = Domain :: model () -> findByPk ($ id); $ ocean = new Ocean (); $ records = $ ocean-> getDomainRecords ($ d-> naam); foreach ($ records als $ r) $ record_id = $ this-> add ($ id, $ r);
Dit is de oceaancomponent getDomainRecords methode:
openbare functie getDomainRecords ($ naam) $ action = $ this-> digitalOcean-> domainRecord (); $ acties = $ actie-> getAll ($ naam); return $ acties;
De DomainRecord toevoegen methode is een beetje meer gedetailleerd:
public function add ($ domain_id, $ record) $ dr = DomainRecord :: model () -> findByAttributes (array ('record_id' => $ record-> id)); if (empty ($ dr)) $ dr = new DomainRecord; $ dr-> domain_id = $ domain_id; $ dr-> record_id = $ record-> id; $ dr-> record_name = $ record-> naam; $ dr-> record_type = $ record-> type; $ dr-> record_data = $ record-> data; if (isset ($ record-> priority)) $ dr-> priority = $ record-> priority; else $ dr-> priority = null; if (isset ($ record-> port)) $ dr-> port = $ record-> port; else $ dr-> port = null; if (isset ($ record-> weight)) $ dr-> weight = $ record-> weight; anders $ dr-> weight = null; $ dr-> actief = 1; $ dr-> created_at = nieuwe CDbExpression ('NU ()'); $ dr-> modified_at = nieuwe CDbExpression ('NU ()'); $ DR-> save (); return $ dr-> id; Dit is hoe het eruit zal zien na de synchronisatie van domeinrecords:
U kunt ook handmatig domeinen en domeinrecords van onze console toevoegen.
Hier is de code in het domeinmodel die de API-aanvraag oproept om het domein toe te voegen:
public function remote_add () $ ocean = new Ocean (); $ domain = $ ocean-> createDomain ($ this-> name, $ this-> ip_address); $ This-> save (); geef waar terug;
Dit is de oceaancomponent addDomain methode:
public function createDomain ($ name, $ ip_address) $ action = $ this-> digitalOcean-> domain (); $ create = $ action-> create ($ name, $ ip_address); return $ create;
Synchroniseer vervolgens de domeinrecords en voeg uw eigen records toe:
Hier is de DomainRecord model- methode remote_add:
publieke functie remote_add ($ id) $ d = Domain :: model () -> findByPk ($ id); $ ocean = new Ocean (); $ record = $ ocean-> createDomainRecord ($ d-> name, $ this-> record_type, $ this-> record_name, $ this-> record_data, $ this-> priority, $ this-> port, $ this-> weight ); $ this-> domain_id = $ id; $ this-> record_id = $ record-> id; $ this-> actief = 1; $ this-> created_at = nieuwe CDbExpression ('NU ()'); $ this-> modified_at = nieuwe CDbExpression ('NU ()'); $ This-> save (); geef waar terug; Dit is de oceaancomponent createDomainRecord methode:
openbare functie createDomainRecord ($ domain_name, $ type, $ name, $ data, $ priority, $ port, $ weight) $ domainRecord = $ this-> digitalOcean-> domainRecord (); if ($ priority == ") $ priority = null; if ($ port ==") $ port = null; if ($ weight == ") $ weight = null; // retourneer de gemaakte DomainRecord-entiteit van het domein 'bar.dk' $ created = $ domainRecord-> create ($ domain_name, $ type, $ name, $ data, $ priority, $ port, $ weight); return $ created;
Je zou zoiets in onze console moeten zien:
Dit is wat de webconsole van Digital Ocean zal laten zien - let op hoe ons lokale beeld en de weergave op afstand nu identiek zijn:
Zoals je misschien hebt gemerkt, mist deze code robuuste foutcontrole, synchronisatie, update, verwijderen en andere toeters en bellen. Ik laat dat aan jou over om uit te breiden zoals je wilt.
Ik hoop dat je deze verkenning van de Digital Ocean DNS API nuttig hebt gevonden.
Aarzel niet om uw vragen en opmerkingen hieronder te plaatsen. Je kunt me ook bereiken via Twitter @reifman of mij rechtstreeks een e-mail sturen. Volg mijn Tuts + -instructorpagina om toekomstige artikelen over gerelateerde onderwerpen te bekijken.
