Projekt: git gradle spring-boot
W każdym (nawet freelancer’skim) projekcie przychodzi moment na to aby zacząć pisać kod i tu już dostajemy wiatr w żagiel i stopy wody pod kilem. W zasadzie ogranicza nas tylko lenistwo z jednej strony i kreatywność z drugiej.
Dla potrzeb prezentacji wybiorę sobie coś na czasie, a będzie to:
- spring-boot
- gradle
- git
- javafx
A zatem bez zbędnych patosów, teorii i literatury zacznijmy od stworzenia kilku plików.
Tworzenie projektu
Zacznijmy od utworzenia repozytorium. Jeśli nie widziałeś mojego wpisu na ten temat to zobacz pierw: php7-git-gitlist.
A teraz do rzeczy. Struktura projektu:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 | └───javafx-git-sample<br> │ .gitignore<br> │ build.gradle<br> │ latest.properties<br> │ settings.gradle<br> │<br> ├───gradle<br> │ release.gradle<br> │<br> └───src<br> └───main<br> ├───java<br> │ └───pl<br> │ └───estrix<br> │ └───javafx<br> │ FilterProp.java<br> │ JavaApplication.java<br> │ MainController.java<br> │<br> └───resources<br> │ logo.png<br> │ main.fxml<br> │<br> └───META-INF<br> spring.factories |
Plik .gitignore
1 2 3 4 | .gradle/<br> .idea/<br> build/<br> *.iml |
Plik build.gradle
1 2 3 4 5 6 7 8 9 | buildscript {<br> repositories {<br> mavenCentral()<br> jcenter()<br> }<br> dependencies {<br> classpath("org.springframework.boot:spring-boot-gradle-plugin:2.0.1.RELEASE")<br> }<br> } |
apply from: ‚gradle/release.gradle’
apply plugin: ‚java’
apply plugin: ‚org.springframework.boot’
apply plugin: ‚io.spring.dependency-management’
bootJar {
mainClassName = ‚pl.estrix.javafx.JavaApplication’
manifest {
attributes ‚Start-Class’: ‚pl.estrix.javafx.JavaApplication’
}
}
springBoot {
mainClassName = ‚pl.estrix.javafx.JavaApplication’
}
repositories {
mavenCentral()
}
sourceCompatibility = 1.8
targetCompatibility = 1.8
dependencies {
compile(„org.springframework.boot:spring-boot-starter”)
testCompile(„junit:junit”)
}
def buildTime() {
new Date().format(‚yyyy.MM.dd HH:mm’)
}
def generatedResources = „$buildDir/resources/main/”
sourceSets {
main {
output.dir(generatedResources, builtBy: ‚generateMyResources’)
}
}
task generateMyResources {
doLast {
def generatedTmp = new File(generatedResources)
if( !generatedTmp.exists() ) {
generatedTmp.mkdirs()
}
def generated = new File(generatedResources, „filter.properties”)
1 2 3 4 5 | generated.text = "estrix.application.biuld-time=${buildTime()}\n" +<br> "estrix.application.name=${project.name}\n" +<br> "estrix.application.version=${project.version}\n"<br> }<br> } |
Plik latest.properties
1 2 3 4 | #Tue Apr 10 16:59:22 CEST 2018<br> bugfix=0<br> major=1<br> minor=0 |
Plik settings.gradle
1 | rootProject.name = 'JavaFxGitSample' |
Plik gradle/release.gradle
Notatka: Pomysł na zarządzanie wersjami pochodzi z https://www.youtube.com/watch?v=Y6SVoXFsw7I
1 2 3 4 5 | class Version {<br> int major<br> int minor<br> int bugfix<br> boolean snapshot = true |
static Version load(File versionFile){
def props = new Properties()
versionFile.withInputStream {
stream -> props.load(stream)
}
def major = Integer.parseInt(props[‚major’])
def minor = Integer.parseInt(props[‚minor’])
def bugfix = Integer.parseInt(props[‚bugfix’])
return new Version(major:major, minor:minor, bugfix:bugfix)
}
String toString(){
„${major}.${minor}.${bugfix}${snapshot ? ‚-SNAPSHOT’:”}”
}
void store(File versionFile){
def props = new Properties()
props[‚bugfix’] = bugfix.toString()
props[‚major’] = major.toString()
props[‚minor’] = minor.toString()
props.store(versionFile.newWriter(), null)
}
Version next(String releaseType = „bugfix”){
if(releaseType == „major”){
return new Version(major:major+1, minor:0, bugfix:0)
}else if(releaseType == „minor”){
return new Version(major:major, minor:minor+1, bugfix:0)
}else{
return new Version(major:major, minor:minor, bugfix:bugfix+1)
}
}
}
def latest = Version.load(rootProject.file(„latest.properties”))
allprojects{
version = latest.next()
}
gradle.taskGraph.whenReady { graph ->
if(graph.hasTask(„:release”)){
allprojects{
version = latest.next(release.type)
version.snapshot = false
}
}
}
task persistVersionInfo(type:Exec){
commandLine „git” , „commit”,”-i”, „latest.properties”, „-m”, „‚ update version to ${-> version }'”
doFirst{
version.store(file(„latest.properties”))
}
}
task tagWorkspace(type:Exec){
commandLine ‚git’, ‚tag’, „${-> version }”
commandLine ‚git’, ‚push’, ‚origin’, ‚HEAD:master’
}
task release(type:Release){
type = System.getProperty(„type”)
dependsOn „build”, „persistVersionInfo”, „tagWorkspace”
}
import org.gradle.api.internal.tasks.options.Option
class Release extends DefaultTask{
@Option(option=”type”, description=”the type of a release.”)
String type = „bugfix”
1 2 3 4 | @TaskAction void release(){<br> println "doing a $type release of ${project.version}"<br> }<br> } |
Plik src/main/java/pl/estrix/javafx/FilterProp.java
1 | package pl.estrix.javafx; |
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
@Component
@ConfigurationProperties(„filter.properties”)
public class FilterProp {
@Value(„${estrix.application.name}”)
private String name;
@Value(„${estrix.application.version}”)
private String version;
@Value(„${estrix.application.biuld-time}”)
private String biuldTime;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getVersion() {
return version;
}
public void setVersion(String version) {
this.version = version;
}
public String getBiuldTime() {
return biuldTime;
}
1 2 3 4 | public void setBiuldTime(String biuldTime) {<br> this.biuldTime = biuldTime;<br> }<br> }<br> |
Plik src/main/java/pl/estrix/javafx/JavaApplication.java
1 | package pl.estrix.javafx; |
import javafx.application.Application;
import javafx.fxml.FXMLLoader;
import javafx.scene.Parent;
import javafx.scene.Scene;
import javafx.stage.Stage;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
@SpringBootApplication
@ComponentScan(„pl.estrix.javafx”)
@PropertySource(„classpath:filter.properties”)
@Configuration
public class JavaApplication extends Application {
private ConfigurableApplicationContext context;
private Parent rootNode;
public static void main(final String[] args) {
Application.launch(args);
}
@Override
public void init() throws Exception {
SpringApplicationBuilder builder = new SpringApplicationBuilder(JavaApplication.class);
context = builder.run(getParameters().getRaw().toArray(new String[0]));
FXMLLoader loader = new FXMLLoader(getClass().getResource(„/main.fxml”));
loader.setControllerFactory(context::getBean);
rootNode = loader.load();
}
@Override
public void start(Stage primaryStage) throws Exception {
primaryStage.setScene(new Scene(rootNode, 480, 320));
primaryStage.centerOnScreen();
primaryStage.show();
}
@Override
public void stop() throws Exception {
context.close();
}
1 | } |
Plik src/main/java/pl/estrix/javafx/MainController.java
1 | package pl.estrix.javafx; |
import javafx.fxml.FXML;
import javafx.scene.control.Label;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class MainController {
@Autowired
private FilterProp filterProp;
@FXML
private Label propName;
@FXML
private Label propVersion;
@FXML
private Label propBuildTime;
1 2 3 4 5 6 7 | @FXML<br> public void initialize() {<br> propName.setText(filterProp.getName());<br> propVersion.setText(filterProp.getVersion());<br> propBuildTime.setText(filterProp.getBiuldTime());<br> }<br> } |
Plik src/main/resources/main.fxml
Plik src/main/resources/META-INF/spring.factories
1 2 | org.springframework.boot.autoconfigure.EnableAutoConfiguration=\<br> pl.estrix.javafx.JavaApplication |
Plik src/main/resources/logo.png
1 | wget http://e-strix.com/wp-content/uploads/2018/04/logo.png -P src/main/resources/ |
Budowa lokalna
Uruchamianie
1 | gradle clean generateMyResources bootRun |
Budowanie jar
1 | gradle clean generateMyResources bootJar |
Uruchamianie
1 | java -jar build\libs\JavaFxGitSample-1.0.1-SNAPSHOT.jar |
No dobra, teraz wiemy jak zbudować aplikację. Ale docelowo ma to robić Ci, zatem zabieramy się za konfigurację job’ów.
Konfiguracja Jenkins
Budowa zdalna
W polu: Repository URL
git@git.e-strix.com:repositories/javafx-git-sample.git
W polu: Repository browser
gitlist
W polu: Repository browser -> URL
git.e-strix.com
W polu: Budowanie -> Invoke Gradle -> Version
Gradle_4_6
W polu: Budowanie -> Tasks
clean generateMyResources bootJar
Podnoszenie wersji
Kroki takie jak w przypadku „Budowa zdalna” z tą różnicą że w:
W polu: Budowanie -> Tasks
clean release --type minor
Gdzie wartość –type przyjmuje wartości:
- major
- minor
- bugfix – domyślny
Publikacja na Landing Page
W polu: Budowanie -> Execute Shell -> Command
mkdir -p release_lib
rm -f ./release_lib/*
cp ${WORKSPACE}/../javafx-git-sample-release/build/libs/*.jar ./release_lib/
rm -f /home/appuser/public_html/download/*.jar
cp ./release_lib/*.jar /home/appuser/public_html/download/
Zakończenie
Jak widzisz storzenie projektu jest dość proste. Mimo że musiałem kilka godzin spędzić na odnalezieniu odpowiedniej dla mojego projektu ścieżki rozwoju. Przetestowałem kilka rozwiązań, pluginów i stwierdziłem że jednak najlepsze rozwiązanie to będzie ręczne napisanie skryptu (mimo że zapożyczyłem rozwiązanie od mądrych ludzi z internetu).
Landing Page dla naszego projektu
Wstęp
Dziś zajmiemy się promocją naszego przyszłego projektu. Do tego najlepiej wykorzystać coś prostego, no dobra ja jestem z tych co nie lubią się męczyć ze stroną internetową. W sumie to narzędzie nie powinno sprawiać problemów, nie ma się co szarpać jeśli nie mamy ludzi od promocji.
Zatem weźmy się do roboty, strona produktu…
I jeszcze raz od początku, zacznijmy od serwera Apache.
Apache + PHP
Już to przerabialiśmy mnóstwo razy, ale i tak zrobimy sobie jeszcze raz, ale trochę inaczej. Zatem do dzieła. Aktualizujemy repozytoria:
apt-get install python-software-properties software-properties-common LC_ALL=C.UTF-8 add-apt-repository ppa:ondrej/php apt-get update
i dalej serwer:
apt-get install apache2 php7.2 php7.2-fpm libapache2-mod-php7.2
I konfigurujemy. Wchodzimy do katalogu stron:
cd /etc/apache2/sites-available/
I tworzymy naszą konfigurację:
vim app.e-strix.com.conf
dalej, uzupełniamy zawartość pliku:
<VirtualHost *:80> ServerAdmin admin@e-strix.pl ServerName app.e-strix.com DocumentRoot /var/www/app.e-strix.com/public_html <Directory "/var/www/app.e-strix.com/public_html/"> AllowOverride All Order allow,deny Allow from all </Directory> ErrorLog /var/www/app.e-strix.com/error.log CustomLog /var/www/app.e-strix.com/access.log combined </VirtualHost>
Dodajemy katalog:
mkdir -p /var/www/app.e-strix.com
Teraz dodamy użytkownika i dodamy do grupy www-data:
adduser appuser usermod -a -G appuser www-data
Tworzymy katalog publc_html w katalohu użytkowanika:
mkdir -p /home/appuser/public_html/
Teraz zrobimy coś nowego, czyli link symboliczny:
ln -s /home/appuser/public_html /var/www/app.e-strix.com
Po co nam to? O tym później…
A teraz niespodzianka, coś nowego. Postawimy sobie serwer FTP’a.
FTP
Po co on nam jest? A no po to by WordPress sam sobie dociągał pluginy czy też aktualizacje. Na początku wspominałem o chęci pozbycia się problemów a to rozwiązanie daruje nam wiele prac administracyjnych.
Teraz instalujemy na VPS’ie demona:
apt-get install vsftpd
Teraz zróbmy kopię zapasową oryginalnego pliku z konfiguracją:
mv /etc/vsftpd.conf /etc/vsftpd.conf.orig
I teraz potrzebujemy własnej konfiguracji, czyli tworzymy nasz plik:
vim /etc/vsftpd.conf
Z zawartością:
listen=YES anonymous_enable=NO local_enable=YES write_enable=YES local_umask=022 dirmessage_enable=YES use_localtime=YES xferlog_enable=YES connect_from_port_20=YES chroot_local_user=YES secure_chroot_dir=/var/run/vsftpd/empty pam_service_name=vsftpd rsa_cert_file=/etc/ssl/certs/ssl-cert-snakeoil.pem rsa_private_key_file=/etc/ssl/private/ssl-cert-snakeoil.key allow_writeable_chroot=YES pasv_enable=YES pasv_min_port=40000 pasv_max_port=50000 seccomp_sandbox=NO user_sub_token=$USER local_root=/home/$USER/public_html userlist_enable=YES userlist_file=/etc/vsftpd.userlist userlist_deny=NO
Notatka: Zwróć uwagę że kopiowanie całości ustawień doda specyficzny znak końca linii, i wtedy serwer może się nie uruchomić.
Teraz zaczyna się już wszystko układać w całość.
Dodajmy teraz użytkownika do listy vsftpd.userlist.
echo "appuser" | tee -a /etc/vsftpd.userlist
I restartujemy naszego daemona:
service vsftpd restart
I tu druga ciekawostka, czyli baza danych.
MySQL
No dobra, zajmijmy się dodaniem bazki. Tutaj też coś mało problemowego. Trzymam się firmy Oracle z większością produktów, dlatego małe projekty stawiam na bazach MySQL. Możesz się sprzeczać o to że są lepsze, że np. Postgresql jest o niebo lepsze, że bla bla bla. Uwierz mi, że źle utworzone zapytanie zarżnie każdą bazę, lub też przechowywanie zbyt dużej ilości danych archiwalnych przymuli każdy filesystem, a nam chodzi tu o prostotę i dostępność.
Zaczynamy oczywiście od instalacji:
apt-get install mysql-server php7.2-mysql
W trakcie tego procecsu, musimy mieć ustalone hasło do root. I w zasadzie tyle. Po zakończonym procesie instalacji możemy utworzyć bazę dla naszego CMS’a i użytkownika z którego będzie się ten CMS łączył do bazki.
Notatka: Nie łączymy się do bazy za pośrednictwem użytkownika root! W przyszłości pokażę dlaczego.
A zatem wchodzimy do MySQL’a z użytkownika root:
mysql -u root -p
I po wpisaniu hasła przystępujemy do tworzenia naszej bazy:
CREATE DATABASE app_e_strix_com;
Mamy bazę, więc dodamy użytkownika:
CREATE USER 'appuser'@'localhost' IDENTIFIED BY 'password';
Nazwa użytkownika bazy jest zbieżna z nazwą użytkownika systemy, ale nie jest zależna. Mamy dowolność w dodawaniu nazw oraz haseł 😉
Teraz nadamy prawa do bazy. Nie chcemy aby żaden problemik pozamiatał nam tabele więc nie damy pełnych praw:
GRANT CREATE,DELETE,INSERT,SELECT,UPDATE ON app_e_strix_com.* TO appuser@localhost;
Notatka: Delete jest dyskusyjne, możemy w prawdzie ustawić trigger, aby nam przenosił dane w inne miejsce ale w tej chwili wykracza to poza potrzeby prezentacji.
Teraz już mamy strukturę naszych katalogów, więc spokojnie możemy dodać naszą konfigurację Apache, a zatem:
a2ensite app.e-strix.com
I przeładowanie:
service apache2 reload
Notatka: Dlaczego teraz a nie wcześniej? Odpowiedź jest prosta, po instalacji MySQL trzeba przeładować apache, aby nowo zainstalowane moduły były widoczne. W prawdzie można przeładować kilka razy, nie zaszkodzi, ale stwierdziłem że wykonam to właśnie w taki sposób.
A teraz nasz CMS, czyli instalacja WordPress’a.
WordPress
W prawdzie można użyć hostingu z już zainstalowanym CMSem, ale takie rozwiązanie jest mało elastyczne. Mam na myśli instalacje innych rzeczy niż tylko jednego narzędzia.
Przejdźmy do katalogu użytkownika:
cd /home/appuser/
I pobieramy WordPress:
wget https://wordpress.org/latest.tar.gz
A teraz rozpakujemy paczkę:
tar zxvf latest.tar.gz
I zawartość przenosimy do katalogu public_html:
mv ./wordpress/* ./public_html/
I czyścimy niepotrzebne pliki:
rm -r latest.tar.gz wordpress/
I nadajemy prawa do katalogu:
chown -R appuser:www-data public_html/ chmod -R 774 public_html/
Z poziomy administracji już wszystko gra, teraz użyjemy przeglądarki do finalizacji procesu instalacji:
A teraz instalacja numer 2, czyli już coś ładnie wygląda.
1. Wpisujemy dane naszej bazki
Teraz wypełnijmy formularz danymi, które ustaliliśmy przy tworzeniu bazy MySQL. I przechodzimy dalej.
2. Ustalamy konto administratora
Warto je sobie zapisać, żeby nie szukać w przyszłości. Mam na myśli sytuację, gdy będzie potrzeba coś zmienić, lub dodać osobę zajmującą się stroną. Gdy nasza aplikacja nabierze rozgłosu, może wystąpić sytuacja że nie będzie możliwości ogarnięcia wszystkiego w pojedynkę.
Klikamy przycisk „Let’s go!”.
Wypełniamy formularz i przechodzimy dalej:
Zakończenie
No i teraz mamy wszystko. Pozostaje nam wybrać sobie ładny layout i theme. Podłączyć statystyki googlowskie, lub coś innego np Piwik’a, lub zupełnie coś innego… Potem integracja z AdSense, może strona na początku na siebie zarobi, i integracja z portalem społecznościowym, ja wybiorę facebook. Ale o tym w przyszłości. Na chwilę obecną mamy domyślny motyw i to w rezultacie jest dobrym fundamentem do pracy.
git + GitList
Wstęp
Każdy etap prowadzenia projektu wiąże się nierozerwalnie z posiadaniem kodu oraz dokumentacji do projektu. Każdy programista wie jak ważny jest czas poświęcony na tworzenie algorytmów i ich implementacja. Jeśli jesteś osobą, która nie doświadczyła jeszcze utraty kodu poprzez błąd systemu lub dysku, spokojnie możesz zignorować poniższy tutorial, w innym przypadku zapraszam do zapoznania się z instrukcją jak postawić własny serwer kontroli wersji za złotówkę miesięcznie.
Oczywiście zapytasz czy słyszałem o dobrodziejstwie takim jak GitHub czy inny serwer. Tak, coś mi się obiło przypadkiem o uszy… Problem jest taki że darmowe konta są publiczne a prywatne kosztuje dziś 7 dolarów amerykańskich. Za tę kwotę można spokojnie wykupić sobie serwer prywatny (trochę więcej niż wersję podstawową) i samodzielnie postawić odpowiednie narzędzia. Nie będę opisywał jak korzystać z Git’a, jest tego pełno w internecie…
W tym artykule poruszę konfigurację systemu Git, opowiem o tym jak zainstalować go na serwerze z systemem Ubuntu, skonfigurować odpowiednie pliki oraz ścieżki. W dalszej części pokażę jak zainstalować klienta webowego GitList do przyjemnego podglądania zmian w repozytorium. Jeśli jesteś fanem Subversion, zachęcam do zobaczenia artykułu o instalacji svn’a wraz z klientem webowym WebSVN tutaj.
| L.P. | Czego potrzebujemy |
| 1 | VPS |
| 2 | System Operacyjny ja wybrałem Ubuntu 16.04 |
| 3 | Dostęp po SSH z prawami root |
| 4 | https://github.com/klaussilveira/gitlist/releases https://s3.amazonaws.com/gitlist/gitlist-0.3.tar.gz |
| 5 | Skonfigurowana domena na serwer VPS |
1. Instalujemy PHP7.2 na Ubuntu 16.04
Gdy mamy zainstalowany system Ubuntu 16.04 w wersji serwerowej, mamy już zainstalowany PHP w wersji 7.0, dla naszego artykułu nie potrzebujemy wyższej wersji (w sumie wersja 5 jest równie dobra) ale pokażę jak podbić wersję do PHP 7.2.
Dodajmy pierw odpowiednie repozytoria do czystej instancji VPSa:
apt-get install python-software-properties software-properties-common LC_ALL=C.UTF-8 add-apt-repository ppa:ondrej/php apt-get update
Teraz usuńmy poprzednie (jeśli istnieją) instalacje:
lub opcja purge, usuwanie z konfiguracjami:
Teraz instalacja cora PHP7:
apt-get install php7.2 php7.2-fpm php7.2-xml -y
i czyścimy śmieci:
Wynik jaki uzyskaliśmy:
# php -v PHP 7.2.3-1+ubuntu16.04.1+deb.sury.org+1 (cli) (built: Mar 6 2018 11:18:25) ( NTS ) Copyright (c) 1997-2018 The PHP Group Zend Engine v3.2.0, Copyright (c) 1998-2018 Zend Technologies with Zend OPcache v7.2.3-1+ubuntu16.04.1+deb.sury.org+1, Copyright (c) 1999-2018, by Zend Technologies
2. Instalujemy GIT’a
Git jest dziś dostarczany do niemal każdej dystrybucji systemu operacyjnego. Jeśli z jakiegoś przypadku nie masz zainstalowanego git’a, oto komenda naprawiająca ten błąd.
apt-get install git
W wyniku oczywiście otrzymamy najnowszą wersję uznaną przez prowajdera:
# git --version git version 2.7.4
3. Instalujemy Apache2
Kolejny krok to instalacja serwera, który będzie obsługiwał klienta webowego. Wybieram Apache ze względu na własne zasiedzenie przy nim. Nie ma też problemu z wykorzystaniem konkurencyjnych produktów.
apt-get install apache2 libapache2-mod-php
Dodajemy jeszcze moduł rewrite, aby pozbyć się niepotrzebnych nazw skryptów z url’a. Po tym musimy zrestartować serwer. Nie wystarczy sam reload, to jest za poważna zmiana ustawień.
a2enmod rewrite service apache2 restart
Wynik:
4. Dodajemy stronę git.e-strix.com
Teraz dodamy konfigurację naszej strony. Jest to konieczne aby zmienić wyświetlany domyślny katalog dla apache.
Notatka: Ważne jest aby dodać do naszych hostów adres IP i nazwę domeny. Dla mnie to będzie git.e-strix.com. Osobiście korzystam z hostingu i definicji rekordów A.
cd /etc/apache2/sites-available
i dalej tworzymy plik konfiguracyjny naszej strony:
vim git.e-strix.com.conf
Notatka: Możesz nie mieć zainstalowanego edytora tekstowego. Dla mojej pracy używam Vim’a, bo go lubię i znam. Nie ma powodów żeby wybierać tylko jego. Jeśli wolisz Nano czy masz zainstalowany program MidnightCommander z wewnętrznym edytorem, śmiało wybierz najlepszą dla siebie opcje.
Zawarość pliku:
<VirtualHost *:80> ServerAdmin kontakt@e-strix.pl ServerName git.e-strix.com DocumentRoot /var/www/git.e-strix.com/public_html/ <Directory "/var/www/git.e-strix.com/public_html/"> DirectoryIndex index.php index.html Options FollowSymLinks AllowOverride All </Directory> ErrorLog /var/www/git.e-strix.com/error.log CustomLog /var/www/git.e-strix.com/access.log combined </VirtualHost>
Tworzymy katalog docelowy, gdzie będą przechowywane pliki aplikacji GitList:
mkdir -p /var/www/git.e-strix.com/public_html
i każemy apache udostępnić naszą stronę w sieci:
a2ensite git.e-strix.com.conf service apache2 reload
Notatka: Pamiętaj o dodaniu przekierowania DNS na IP serwera na którym stawiasz serwer.
Efekt:
5. Instalujemy GitList
Aplikacja GitList jest stworzona w PHP i jest prosta w obsłudze, dlatego postanowiłem o niej napisać. Jako programista nie mam zamiaru poświęcać więcej czasu na administrację serwer niż jest to konieczne. Dlatego wybieram narzędzia oparte o PHP aby nie bawić się w budowanie, publikowanie i namiętne analizowanie dzienników.
Zatem podążając wg instrukcji:
- Pobieramy GitList z gitlist.org i wypakowujemy do naszego katalogu /var/www/gitlist.e-strix.com/public_html/
- Zmieniamy nazwę pliku config.ini-example na config.ini
- Podmieniamy ścieżkę repozytorium
- Tworzymy catalog cache z uprawnieniami czytanie/pisanie wg. instrukcji
Notatka: Ja wybrałem wersję 0.3 – z powodu błędu jaki uzyskałem w nowszej wersji. W przyszłości spróbuję aktualizować aplikację, natomiast na chwilę obecną będę obserwował. Błędy wynikają niestety z wersji PHP7, dla wersji 7.2 build z 6 marca dalej nie pomógł.
cd /var/www/git.e-strix.com/public_html wget https://s3.amazonaws.com/gitlist/gitlist-0.3.tar.gz
Rozpakujemy pobrane archiwum i zmienimy nazwę katalogu na public_html, jako ten z którego korzysta serwer. W dalszej kolejności należy nadać właściciela dla wszystkich plików.
Notatka: Jeśli korzystasz z użytkownika root do wykonania wszystkich czynność (zakładam że tak, i instalujesz na świeżej instancji serwera), to zmuszony jesteś nadać odpowiednie prawa do wszystkich katalogów i plików, lub najprościej zmienić właściciela plików. Domyślnym użytkownikiem, który obsługuje serwer apache jest www-data, i grupa www-data.
tar zxvf gitlist-0.3.tar.gz rm gitlist-0.3.tar.gz cd .. chown -R www-data:www-data public_html/
W porządku teraz wg instrukcji musimy stworzyć katalog cache i nadać mu pełne prawa (sic!) w naszej aplikacji, więc wjedźmy do katalogu public_html i zróbmy to o co nas proszą:
cd public_html/ chmod 777 cache
Notatka: Katalog oczywiście się utworzy z właścicielem i grupą „root”, przy tych uprawnieniach nie mamy się co martwić brakiem uprawnień, ponieważ uprawnienia 777 są najwyższe jakie mogą być.
Teraz dodajmy konfigurację czyli zgodnie z ww. instrukcją, edytujemy plik config.ini i określamy gdzie będzie znajdowało się nasze repozytorium.
vim config.ini
Domyślnie jest ustawiona wartość „/home/git/repositories/„, myślę że spokojnie możemy wykorzystać ten katalog. Dla mojej pracy nie ma szczególnych wymagań co do tej struktury, a zatem do dzieła przejdźmy do dodania użytkownika git.
[git] client = '/usr/bin/git' ; Your git executable path repositories = '/home/git/repositories/' ; Path to your repositories
Dodajemy użytkownika i uzupełnimy potrzebne dane:
adduser git
Teraz należy dodać nasz katalog repozytorium:
mkdir -p /home/git/repositories/
Teraz wejdźmy do środka i dodajmy nasze pierwsze repozytorium:
cd /home/git/repositories/ git init --bare project1.git chown -R git:git project1.git/
Czas sprawdzić czy nasze repozytorium działa i czy możemy się do niego dostać. Najlepiej sprawdzić to poprzez wykorzystanie innej maszyny, zatem przechodzimy na komputer lokalny lub inny dostępny i spróbujemy pobrać nasz projekt:
git clone git@git.e-strix.com:repositories/project1.git
No masz, działa…
Teraz wejdźmy do środka i zróbmy komit inicjalizacyjny:
cd project1/ touch .gitignore git add .gitignore git commit -m "init commit" git push
Notatka: Pamiętaj o nadaniu odpowiednich uprawnień lub przypinanie użytkownika do odpowiedniej grupy w systemie.
W rezultacie otrzymamy wynik:
