Iniziare con OKD sul desktop Linux

OKD è l'edizione open source della community upstream della piattaforma container OpenShift di Red Hat. OKD è una piattaforma di gestione e orchestrazione dei container basata su Docker e Kubernetes.

OKD è una soluzione completa per gestire, distribuire e utilizzare applicazioni containerizzate che (oltre alle funzionalità fornite da Kubernetes) include un'interfaccia Web di facile utilizzo, strumenti di compilazione automatizzati, funzionalità di routing e funzionalità di monitoraggio e aggregazione della registrazione.

OKD offre diverse opzioni di implementazione mirate a requisiti diversi con nodi master singoli o multipli, funzionalità ad alta disponibilità, registrazione, monitoraggio e altro ancora. Puoi creare cluster OKD piccoli o grandi quanto vuoi.

Contenitori Linux

• Cosa sono i container Linux?
• Un'introduzione alla terminologia dei contenitori
• Download:Primer sui contenitori
• Operatori Kubernetes:automatizzare la piattaforma di orchestrazione dei container
• eBook:modelli Kubernetes per la progettazione di app cloud native
• Cos'è Kubernetes?

Oltre a queste opzioni di distribuzione, OKD fornisce un modo per creare un cluster all-in-one locale sulla propria macchina utilizzando oc strumento da riga di comando. Questa è un'ottima opzione se vuoi provare OKD localmente senza impegnare le risorse per creare un cluster multinodo più grande o se vuoi avere un cluster locale sulla tua macchina come parte del tuo flusso di lavoro o processo di sviluppo. In questo caso, puoi creare e distribuire le applicazioni in locale utilizzando le stesse API e interfacce necessarie per distribuire l'applicazione su scala più ampia. Questo processo garantisce un'integrazione perfetta che previene problemi con le applicazioni che funzionano nell'ambiente dello sviluppatore ma non in produzione.

Questo tutorial ti mostrerà come creare un cluster OKD utilizzando oc cluster up in una scatola Linux.

1. Installa Docker

Il occluso in alto Il comando crea un cluster OKD locale sulla tua macchina utilizzando i contenitori Docker. Per utilizzare questo comando, è necessario che Docker sia installato sulla macchina. Per OKD versione 3.9 e successive, Docker 1.13 è la versione minima consigliata. Se Docker non è installato sul tuo sistema, installalo utilizzando il tuo gestore di pacchetti di distribuzione. Ad esempio, su CentOS o RHEL, installa Docker con questo comando:

$ sudo yum install -y docker  

Su Fedora, usa dnf:

$ sudo dnf install -y docker  

Questo installa Docker e tutte le dipendenze richieste.

2. Configura il registro non sicuro Docker

Una volta installato Docker, è necessario configurarlo per consentire la comunicazione con un registro non sicuro all'indirizzo 172.30.0.0/16. Questo registro non sicuro verrà distribuito con il tuo cluster OKD locale in un secondo momento.

Su CentOS o RHEL, modifica il file /etc/docker/daemon.json aggiungendo queste righe:

{
        "insecure-registries":["172.30.0.0/16"]
}

Su Fedora, modifica il file /etc/containers/registries.conf aggiungendo queste righe:

[registries.insecure]
registries =['172.30.0.0/16']

3. Avvia Docker

Prima di avviare Docker, crea un gruppo di sistema denominato docker e assegna questo gruppo al tuo utente in modo da poter eseguire i comandi Docker con il tuo utente, senza richiedere l'accesso come root o sudo. Ciò ti consente di creare il tuo cluster OKD utilizzando il tuo utente.

Ad esempio, questi sono i comandi per creare il gruppo e assegnarlo al mio utente locale, ricardo :

$ sudo groupadd docker
$ sudo usermod -a -G docker ricardo

Devi disconnetterti e riconnetterti per vedere la nuova associazione di gruppo. Dopo aver effettuato nuovamente l'accesso, esegui l'id comando e assicurati di essere un membro della docker gruppo:

$ id
uid=1000(ricardo) gid=1000(ricardo) groups=1000(ricardo),10(ruota),1001(docker) 
context=unconfined_u:unconfined_r:unconfined_t:s0 -s0:c0.c1023

Ora avvia e abilita il demone Docker in questo modo:

$ sudo systemctl start docker
$ sudo systemctl abilita docker
Creato collegamento simbolico da /etc/systemd/system/multi-user.target.wants/docker.service a /usr/lib/systemd/ system/docker.service.

Verifica che Docker sia in esecuzione:

Versione $ docker
Client:
 Versione:        1.13.1
 Versione API:    1.26
 Versione pacchetto:docker-1.13.1-75.git8633870.el7.centos. x86_64
 Go version:     go1.9.4
 Git commit:     8633870/1.13.1
 Costruito:          Ven Sep 28 19:45:08 2018
 OS/Arch:        linux/amd64

Server:
 Versione:        1.13.1
 Versione API:    1.26 (versione minima 1.12)
 Versione pacchetto:docker-1.13.1-75.git8633870.el7. centos.x86_64
 Versione go:     go1.9.4
 Git commit:     8633870/1.13.1
 Costruito:          Ven Sep 28 19:45:08 2018
 OS/Arch:        linux/ amd64
 Sperimentale:   falso

Assicurati che l'opzione del registro non sicuro sia stata abilitata eseguendo info docker e cercando queste righe:

$ info docker
... Salto output lungo ...
Registri non sicuri:
 172.30.0.0/16
 127.0.0.0/8

4. Apri le porte del firewall

Quindi, apri le porte del firewall per assicurarti che i tuoi contenitori OKD possano comunicare con l'API master. Per impostazione predefinita, alcune distribuzioni hanno il firewall abilitato, che blocca la connettività richiesta dai contenitori OKD all'API master. Se il tuo sistema ha il firewall abilitato, devi aggiungere regole per consentire la comunicazione sulle porte 8443/tcp per l'API principale e 53/udp per la risoluzione DNS sulla sottorete del bridge Docker.

Per CentOS, RHEL e Fedora, puoi utilizzare firewall-cmd strumento da riga di comando per aggiungere le regole. Per altre distribuzioni, puoi utilizzare il gestore firewall fornito, come UFW o iptables.

Prima di aggiungere le regole del firewall, ottenere l'indirizzo della sottorete di rete del bridge Docker, in questo modo:

$ rete Docker ispeziona bridge | grep Sottorete
                    "Sottorete":"172.17.0.0/16",

Abilita le regole del firewall usando questa sottorete. Per CentOS, RHEL e Fedora, usa firewall-cmd per aggiungere una nuova zona:

$ sudo firewall-cmd --permanent --new-zone okdlocal
success

Includi l'indirizzo di sottorete ottenuto in precedenza come origine per la nuova zona:

$ sudo firewall-cmd --permanent --zone okdlocal --add-source 172.17.0.0/16
success

Successivamente, aggiungi le regole richieste a okdlocal zona:

$ sudo firewall-cmd --permanent --zone okdlocal --add-port 8443/tcp
success
$ sudo firewall-cmd --permanent --zone okdlocal --add-port 53 /udp
successo
$ sudo firewall-cmd --permanent --zone okdlocal --add-port 8053/udp
successo

Infine, ricarica il firewall per abilitare le nuove regole:

$ sudo firewall-cmd --reload
success

Assicurati che la nuova zona e le regole siano in vigore:

$ sudo firewall-cmd --zone okdlocal --list-sources
172.17.0.0/16
$ sudo firewall-cmd --zone okdlocal --list-ports
8443/ TCP 53/udp 8053/udp

Il tuo sistema è pronto per avviare il cluster. È ora di scaricare gli strumenti del client OKD.

5. Scarica gli strumenti client OKD

Per distribuire un cluster OKD locale utilizzando oc , è necessario scaricare il pacchetto degli strumenti del client OKD. Per alcune distribuzioni, come CentOS e Fedora, questo pacchetto può essere scaricato come RPM dai repository ufficiali. Tieni presente che questi pacchetti possono seguire il ciclo di aggiornamento della distribuzione e di solito non sono la versione più recente disponibile.

Per questo tutorial, scarica il pacchetto client OKD direttamente dal repository GitHub ufficiale in modo da poter ottenere la versione più recente disponibile. Al momento della scrittura, questo era OKD v3.11.

Vai alla pagina dei download di OKD per ottenere il collegamento agli strumenti OKD per Linux, quindi scaricalo con wget :

$ cd ~/Downloads/
$ wget https://github.com/openshift/origin/releases/download/v3.11.0/openshift-origin-client-tools-v3.11.0-0cbc58b-linux -64bit.tar.gz

Decomprimi il pacchetto scaricato:

$ tar -xzvf openshift-origin-client-tools-v3.11.0-0cbc58b-linux-64bit.tar.gz  

Infine, per semplificare l'utilizzo di oc comando a livello di sistema, spostalo in una directory inclusa nel tuo $PATH variabile. Una buona posizione è /usr/local/bin :

$ sudo cp openshift-origin-client-tools-v3.11.0-0cbc58b-linux-64bit/oc /usr/local/bin/ 

Una delle caratteristiche più belle di oc il comando è che è un singolo binario statico. Non è necessario installarlo per usarlo.

Verifica che il oc il comando funziona:

Versione $ oc
oc v3.11.0+0cbc58b
kubernetes v1.11.0+d4cacc0
caratteristiche:Basic-Auth GSSAPI Kerberos SPNEGO

6. Avvia il tuo cluster OKD

Una volta che hai tutti i prerequisiti, avvia il tuo cluster OKD locale eseguendo questo comando:

$ oc cluster up 

Questo comando si connette al demone Docker locale, scarica tutte le immagini richieste da Docker Hub e avvia i contenitori. La prima volta che lo esegui, ci vogliono alcuni minuti per completarlo. Al termine, vedrai questo messaggio:

... Salto dell'output lungo ...

Server OpenShift avviato.

Il server è accessibile tramite console Web all'indirizzo:
    https://127.0 .0.1:8443

Sei ​​loggato come:
    Utente:    sviluppatore
    Password:

Per accedere come amministratore:
    oc login -u system:admin

Accedi alla console web di OKD utilizzando il browser e navigando su https://127.0.0.1:8443:

Dalla riga di comando, puoi verificare se il cluster è in esecuzione immettendo questo comando:

Stato cluster $ oc
URL console Web:https://127.0.0.1:8443/console/

Config è nella directory host 
I volumi sono nella directory host 
I volumi persistenti si trovano nella directory host /home/ricardo/openshift.local.clusterup/openshift.local.pv
I dati verranno eliminati quando il cluster viene distrutto

Puoi anche verificare che il tuo cluster funzioni accedendo come system:admin utente e verificando i nodi disponibili utilizzando oc strumento da riga di comando:

$ oc login -u system:admin
Accedi a "https://127.0.0.1:8443" come "system:admin" utilizzando le credenziali esistenti.

Hai accesso a i seguenti progetti e puoi passare da uno all'altro con 'oc project ':

    default
    kube-dns
    kube-proxy
    kube-public
    kube-system
  * myproject
    openshift
    openshift-apiserver
    openshift-controller-manager
    openshift-core-operatori
    openshift-infra
    openshift-node
    openshift-service-cert-signer
    openshift-web-console

Utilizzo del progetto "myproject".

$ oc get nodes 
NOME        STATO    RUOLI     ETÀ       VERSIONE
localhost   Pronto         52m       v1.11.0+d4cacc0

Poiché si tratta di un cluster all-in-one locale, viene visualizzato solo localhost nell'elenco dei nodi.

7. Prova con il fumo il tuo cluster

Ora che il tuo cluster OKD locale è in esecuzione, crea un'app di test per eseguire il test di fumo. Usa OKD per creare e avviare l'applicazione di esempio in modo da assicurarti che i diversi componenti funzionino.

Inizia accedendo come sviluppatore utente:

$ oc login -u developer
Accedi a "https://127.0.0.1:8443" come "sviluppatore" utilizzando le credenziali esistenti.

Hai un progetto su questo server:"myproject"

Utilizzo del progetto "myproject".

Verrai assegnato automaticamente a un nuovo progetto vuoto denominato mioprogetto . Crea un'applicazione PHP di esempio basata su un repository GitHub esistente, come questo:

$ oc new-app php:5.6~https://github.com/rgerardi/ocp-smoke-test.git 
--> Trovato l'immagine 92ed8b3 (5 mesi) nel flusso di immagini "openshift/ php" sotto il tag "5.6" per "php:5.6"

    Apache 2.4 con PHP 5.6 
    -------------------- --- 
    PHP 5.6 disponibile come contenitore è una piattaforma di base per la creazione e l'esecuzione di varie applicazioni e framework PHP 5.6. PHP è un linguaggio di scripting incorporato in HTML. PHP tenta di rendere facile per gli sviluppatori la scrittura di pagine Web generate dinamicamente. PHP offre anche l'integrazione di database integrata per diversi sistemi di gestione di database commerciali e non commerciali, quindi scrivere una pagina Web abilitata per database con PHP è abbastanza semplice. L'uso più comune della codifica PHP è probabilmente quello di sostituire gli script CGI.

    Tags:builder, php, php56, rh-php56

    * Una build sorgente che utilizza il codice sorgente da https://github.com/rgerardi/ocp-smoke-test.git verrà creato
      * L'immagine risultante verrà inviata al tag image stream "ocp-smoke-test:latest"
      * Usa 'start-build' per attivare una nuova build
    * Questa immagine verrà distribuita nella configurazione di distribuzione "ocp-smoke-test"
    * Le porte 8080/tcp, 8443/tcp verranno bilanciate dal servizio "ocp-smoke-test"
      * Altri contenitori possono accedere a questo servizio tramite il nome host "ocp-smoke-test"

--> Creazione di risorse ...
    imagestream. image.openshift.io "ocp-smoke-test" creato
    buildconfig.build.openshift.io "ocp-smoke-test" creato
    deploymentconfig.apps.openshift.io "ocp-smoke-test" creato
    servizio "ocp-smoke-test" creato
--> Operazione riuscita
    Compilazione pianificata, utilizzare 'oc logs -f bc/ocp-smoke -test' per monitorarne l'avanzamento.
    L'applicazione non è esposta. Puoi esporre i servizi al mondo esterno eseguendo uno o più dei seguenti comandi:
     'oc espone svc/ocp-smoke-test' 
    Esegui 'oc status' per visualizzare la tua app.

OKD avvia il processo di compilazione, che clona il repository GitHub fornito, compila l'applicazione (se richiesto) e crea le immagini necessarie. Puoi seguire il processo di compilazione codando il suo registro con questo comando:

$ oc logs -f bc/ocp-smoke-test
Cloning "https://github.com/rgerardi/ocp-smoke-test.git" ...
        Commit:391a475713d01ab0afab700bab8a3d7549c5cc27 ( Create index.php)
        Autore:Ricardo Gerardi 
        Data:  Mar ​​2 ottobre 13:47:25 2018 -0400
Utilizzando 172.30.1.1:5000/ openshift/php@sha256:f3c95020fa870fcefa7d1440d07a2b947834b87bdaf000588e84ef4a599c7546 come immagine del builder s2i
---> Installazione dell'origine applicazione...
=> sourcing 20-copy-config.sh ...
---> 04:53:28     Elaborazione di una configurazione httpd arbitraria aggiuntiva fornita da s2i ...
=> sourcing 00-documentroot.conf ...
=> sourcing 50-mpm-tuning.conf ...
=> sourcing 40-ssl-certs.sh ...
Pushing image 172.30.1.1:5000/myproject/ocp-smoke-test:latest ...
Push 1/10 strati, 10% completo
Push riuscito

Al termine del processo di compilazione, OKD avvia automaticamente l'applicazione eseguendo un nuovo pod basato sull'immagine creata. Puoi vedere questo nuovo pod con questo comando:

$ oc get pods
NOME                     PRONTO     STATUS      RIAVVIA   ETÀ
ocp-smoke-test-1-build   0/1       Completato   0          1m
ocp-smoke-test-1-g 1/76  1       In esecuzione     0          7s

Puoi vedere che sono stati creati due pod; il primo (con lo stato Completato) è il pod utilizzato per costruire l'applicazione. Il secondo (con lo stato In esecuzione) è l'applicazione stessa.

OKD crea inoltre un servizio per questa applicazione. Verificalo usando questo comando:

$ oc get service
NAME             TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)             AGE
ocp-smoke-test   ClusterIP   172.30.232.241           8080/TCP, 172.30.232.241 pre> 

 Infine, esponi questo servizio esternamente utilizzando i percorsi OKD in modo da poter accedere all'applicazione da un browser locale:
 
$ oc esporre svc ocp-smoke-test
route.route.openshift.io/ocp-smoke-test esposto

$ oc get route
NAME             HOST/PORT PERCORSO      SERVIZI         PORTO       TERMINAZIONE   WILDCARD
ocp-smoke-test   ocp-smoke-test-myproject.127.0.0.1.nip.io             ocp-smoke-test   8080-tcp                 Nessuno
 Verifica che la tua nuova applicazione sia in esecuzione accedendo a http://ocp-smoke-test-myproject.127.0.0.1.nip.io in un browser web:
 

  
 

 Puoi anche vedere lo stato della tua applicazione accedendo alla console web di OKD:
 

  
 
Ulteriori informazioni
 

 Puoi trovare maggiori informazioni su OKD sul sito ufficiale, che include un collegamento alla documentazione di OKD.
 

 Se è la prima volta che lavori con OKD/OpenShift, puoi apprendere le basi della piattaforma, incluso come creare e distribuire applicazioni containerizzate, attraverso il portale di apprendimento interattivo. Un'altra buona risorsa è il canale YouTube ufficiale di OpenShift.