Share
Hva du skal skapeI november 2014 annonserte Digital Ocean sin nylig oppgraderte DNS-hosting-tjeneste. I tillegg til å være rask og pålitelig, har brukere opplevd nær øyeblikkelige oppdateringer av DNS-poster. Enhver utvikler eller systemadministrator kan sette pris på fordelene ved dette: Ikke lenger venter på oppdateringer av IP-adresse under systemmigreringer. I denne opplæringen skal vi utvide funksjonaliteten til konsollprogrammet vi bygde sist gang for å inkludere styring av Digital Oceans DNS-tjeneste.
Igjen kan du laste ned gratis konsollprogrammet fra Tuts + Github-depotet. Jeg har lagt ut en detaljert installasjonsveiledning for konsollprogrammet på nettstedet mitt. Du kan også utforske min generiske installasjonsveiledning for Digital Ocean-apper.
Mens du kan bruke Digital Ocean webkonsollen til å administrere DNS-postene, kan det hende du finner det fordelaktig å programmere administrere dem via API.
Dokumentasjon for Digital Oceans DNS API-tjenester ligger på tvers av to hovedområder:
Vi vil først fokusere på å konfigurere domenene dine og deretter legge til de enkelte DNS-postene.
Før du kan aktivere Digital Oceans egne DNS-tjenester, må du overføre domenenavnervennene dine til Digital Ocean navneservere:
Jeg skal legge til StarWars.io-domenet mitt for denne opplæringsdemonstrasjonen. Her er navnet på serverendringen min på domeneregistratoren min:
Du finner kanskje også hvordan du peker på DigitalOcean Nameservers fra Common Domain Registrars.
Først la vi legge til et domene til Digital Ocean's DNS gjennom sitt webgrensesnitt. Langs den venstre navigasjonsmenyen klikker du på DNS:
Klikk Legg til domenenavn:
Slik viser Digital Ocean DNS-posten din. Det er fint at det viser deg den genererte sonen filen nedenfor:
Deretter legger vi til et domene En rekord for www.starwars.io:
Nå, la oss utforske API-en, ved å laste ned noen av domenene og domenepostene vi nettopp har opprettet.
La oss først laste ned listen over domenene våre ved hjelp av API. I konsollprogrammet klikker du domener i navigeringsfeltet og klikk Sync i høyre meny.
De DomainController koden ser slik ut:
offentlig funksjon actionSync () $ domain = new Domain (); $ Domene-> sync (); $ Dette-> omdirigere ( '/ domene / admin');
Domenemodellen kaller deretter våre Ocean-komponentfunksjoner og legger til hvert domene som er funnet i vår lokale database:
offentlig funksjon synkronisering () $ ocean = new Ocean (); $ domener = $ ocean-> getDomains (); foreach ($ domener som $ d) $ domain_id = $ this-> add ($ d);
Her er API-koden fra Ocean-komponenten for å hente domenelisten:
offentlig funksjon getDomains () // returnere handlingen api $ action = $ this-> digitalOcean-> domain (); // returnere en samling av Handlingsenhet $ actions = $ action-> getAll (); returnere $ handlinger;
Her er Domain-modellen Legg til metode:
Accentsconagua
offentlig funksjon legg til ($ domain) $ d = Domain :: model () -> findByAttributes (array ('name' => $ domain-> navn)); hvis (tomt ($ d)) $ d = nytt domene; $ d-> name = $ domain-> navn; $ d-> ttl = $ domain-> ttl; $ d-> zone = $ domain-> zoneFile; $ d-> aktiv = 1; $ d-> created_at = $ d-> created_at; $ d-> modified_at = ny CDbExpression ('NU ()'); $ D-> Lagre (); returner $ d-> id; Du bør se noe slikt etter at det er fullført:
Klikk på administrer ikon i Starwars-raden, og du ser noe slikt:
La oss da synkronisere domenepostene for starwars.io. Klikk Synkroniser Domain Records-dette vil ringe til SyncRecords handling i DomainController:
offentlig funksjon actionSyncrecords ($ id) $ dr = nytt DomainRecord (); $ Dr-> sync ($ id); $ Dette-> omdirigere ( '/ domene / vis /'.$ id);
De DomainRecord Modellsynkroniseringsmetode ser slik ut. Det gjør en forespørsel om domenenavnets poster og legger hver til DomainRecord bord i vår lokale database:
synkronisering av offentlig funksjon ($ id) // oppslagsdomen $ d = Domene :: modell () -> findByPk ($ id); $ ocean = nytt hav (); $ records = $ ocean-> getDomainRecords ($ d-> navn); foreach ($ poster som $ r) $ record_id = $ this-> add ($ id, $ r);
Her er Ocean-komponenten getDomainRecords metode:
offentlig funksjon getDomainRecords ($ navn) $ action = $ this-> digitalOcean-> domainRecord (); $ actions = $ action-> getAll ($ navn); returnere $ handlinger;
De DomainRecord legg til metode er litt mer detaljert:
offentlig funksjon legg til ($ domain_id, $ record) $ dr = DomainRecord :: model () -> findByAttributes (array ('record_id' => $ record-> id)); hvis (tomt ($ dr)) $ dr = nytt DomainRecord; $ dr-> domain_id = $ domain_id; $ dr-> record_id = $ record-> id; $ dr-> record_name = $ record-> navn; $ dr-> record_type = $ record-> type; $ dr-> record_data = $ record-> data; hvis (isset ($ record-> prioritet)) $ dr-> priority = $ record-> prioritet; ellers $ dr-> priority = null; hvis (isset ($ record-> port)) $ dr-> port = $ record-> port; ellers $ dr-> port = null; hvis (isset ($ record-> weight)) $ dr-> vekt = $ record-> vekt; ellers $ dr-> vekt = null; $ dr-> aktiv = 1; $ dr-> created_at = ny CDbExpression ('NU ()'); $ dr-> modified_at = ny CDbExpression ('NU ()'); $ Dr-> Lagre (); returner $ dr-> id; Slik ser det ut etter at domenepostene synkroniseres:
Du kan også legge til domener og domeneregistre fra konsollen manuelt.
Her er koden i Domenemodellen som påkaller API-forespørselen om å legge til domenet:
offentlig funksjon remote_add () $ ocean = new Ocean (); $ domain = $ ocean-> createDomain ($ this-> navn, $ this-> ip_address); $ Dette-> Lagre (); returnere sant;
Her er Ocean-komponenten addDomain metode:
offentlig funksjon createDomain ($ navn, $ ip_address) $ action = $ this-> digitalOcean-> domain (); $ create = $ action-> create ($ navn, $ ip_address); returner $ create;
Synkroniser deretter domenepostene og legg til din egen:
Her er DomainRecord modell remote_add-metoden:
offentlig funksjon remote_add ($ id) $ d = Domain :: model () -> findByPk ($ id); $ ocean = nytt hav (); $ record = $ ocean-> createDomainRecord ($ d-> navn, $ this-> record_type, $ this-> record_name, $ this-> record_data, $ this-> prioritet, $ this-> port, $ this-> vekt ); $ this-> domain_id = $ id; $ this-> record_id = $ record-> id; $ this-> active = 1; $ this-> created_at = ny CDbExpression ('NU ()'); $ this-> modified_at = ny CDbExpression ('NU ()'); $ Dette-> Lagre (); returnere sant; Her er Ocean-komponenten createDomainRecord metode:
offentlig funksjon createDomainRecord ($ domain_name, $ type, $ navn, $ data, $ prioritet, $ port, $ vekt) $ domainRecord = $ this-> digitalOcean-> domainRecord (); hvis ($ prioritet == ") $ prioritet = null; hvis ($ port ==") $ port = null; hvis ($ weight == ") $ weight = null; // returner den opprettede DomainRecord-enheten til domenet 'bar.dk' $ created = $ domainRecord-> opprett ($ domain_name, $ type, $ navn, $ data, $ prioritet, $ port, $ vekt), returner $ opprettet;
Du bør se noe slikt i konsollen vår:
Her er hva Digital Oceans webkonsoll vil vise - legg merke til hvordan vår lokale visning og fjernsynet nå er identiske:
Som du kanskje har lagt merke til, mangler denne koden robust feilkontroll, synkronisering, oppdatering, sletting og andre klokkene og fløyter. Jeg forlater det for deg å utvide som du ønsker.
Jeg håper du har funnet denne utforskningen av Digital Ocean DNS API for å være nyttig.
Ta gjerne inn dine spørsmål og kommentarer nedenfor. Du kan også nå meg på Twitter @ reifman eller email meg direkte. Følg min Tuts + instruktørside for å se fremtidige artikler om relaterte emner.
