Posts on BigDataPassion

DataMass Gdańsk Summit 2023

Fri, 22 Sep 2023 00:00:00 +0000

Czy jesteś gotowy, aby zagłębić się w świat rozwiązań Big Data opartych na chmurze? Jeśli tak, zapraszamy Cię na Data Mass Gdańsk Summit 2023, podczas którego możesz uwolnić pełen potencjał technologii opartych na danych i zdobyć bezcenny wgląd w Big Data, Data Science, Machine Learning i AI, a wszystko to w kontekście najnowocześniejszych rozwiązań chmurowych.

Oto szczegóły, które musisz znać:

Wydarzenie: Data Mass Gdańsk Summit 2023
Data: 5 października 2023 r
Lokalizacja: Centrum Konferencyjne Muzeum II Wojny Światowej, Gdańsk, Polska

Ekskluzywna zniżka 20%: Nie przegap naszej ekskluzywnej oferty! Użyj specjalnego kodu „BIGDATAPASSION20”, aby odblokować 20% zniżki na bilet na konferencję.

Zarejestruj się teraz, aby zapewnić sobie miejsce

Dlaczego warto wziąć udział w Data Mass Gdańsk Summit 2023?

Połącz się osobiście: Spotkajmy się wreszcie w Gdańsku! Ciesz się możliwością nawiązania kontaktów z innymi entuzjastami danych i ekspertami branżowymi, a wszystko to pod jednym dachem.
Poszerzaj swoją wiedzę: zdobywaj spostrzeżenia i wiedzę na temat Big Data, analityki danych, uczenia maszynowego i sztucznej inteligencji, ze szczególnym uwzględnieniem rozwiązań chmurowych.
Poznaj ekspertów branżowych: wejdź w interakcję z wybitnymi ekspertami i praktykami z najlepszych firm opartych na danych.
Warsztaty praktyczne: Dołącz do warsztatów technicznych prowadzonych przez doświadczonych praktyków, oferujących praktyczne umiejętności i spostrzeżenia.
Publiczność: Dołącz do wyjątkowego grona entuzjastów danych z Polski i świata.

Mamy ekscytujący zestaw prelegentów i tematów, których nie możesz przegapić, w tym:

Improving Psychotherapy through Data: Motivational Interviewing Optimization via NLP, Amit Spinrad, Data Scientist at Eleos Health
AI Products: faster path from being right to being loved, Dainius Kniuksta, Artificial Intelligence Product Lead at Forecast.app
Replacing the Data Platform during Hyper-Growth, Paweł Kupidura, Senior Software Engineer at Bolt
Tracking All Ships in the World - sea of opportunities, Marek Skolimowski, Lead Analytics Solution Developer at DNV
ML at Scale. How to productionize and operationalize hundreds of ML solutions in a simple and reliable way?, Tomasz Deręgowski, Director AI/ML Engineering at Nike
Using Cloud Data Model to create control groups for Alexa users (at scale), Xingchen Ling, Senior Data Scientist, and Maciej Chmielarz, Software Development Manager, both from Amazon

Nie czekaj!

To Twoja szansa na zdobycie praktycznej wiedzy od najlepszych ekspertów w swojej dziedzinie i podniesienie swoich umiejętności na wyższy poziom.

Zarejestruj się już teraz, aby zapewnić sobie miejsce na Data Mass Gdańsk Summit 2023. Pamiętaj o ekskluzywnym rabacie 20%, koniecznie podczas rejestracji użyj kodu „BIGDATAPASSION20”.

Jeśli masz jakieś pytania lub potrzebujesz dodatkowych informacji, nie wahaj się z nami skontaktować. Do zobaczenia na Data Mass Gdańsk Summit w październiku 2023! Gorące pozdrowienia, WDTT

Przegląd rozwiazań Big Data On Premise i Chmury Publicznej

Tue, 28 Mar 2023 00:00:00 +0000

Świat (Big) Data jest pełny narzędzi pozwalających na pracę z danymi. Możemy przebierać w rozwiązaniach open source, komercyjnych oraz cloud native. Niestety wybór odpowiednich narzędzi nie jest prosty. By ułatwić sobie to zadanie, zacząłem spisywać najpopularniejsze narzędzia wykorzystywane w świecie danych. Dodatkowo podzielił te narzędzia na odpowiednie grupy względem środowiska pracy oraz zastosowania.

Poniżej moje zestawienie narzędzi, mam nadzieję, że będzie przydatna nie tylko dla mnie :)

Jeśli ktoś woli format arkusza kalkulacyjnego, lista jest dostępna także tutaj.

Jeśli uważasz, że warto dodać do tej listy jakieś narzędzie, proszę o informację na maila, komentarz pod wpisem lub komentarz w arkuszu.

Tabela jest podzielona na 6 kolumn:

Zastosowanie / Cel biznesowy - Tutaj podstawowe przeznaczenie grupy narzędzi
Self manage (on premise or public cloud) - narzędzia którymi my zarządzamy bez względu czy zainstalujemy je w środowisku on premise czy w chmurze publicznej
Amazon Web Services - rozwiązania natywne dla AWS
Google Cloud Platform - rozwiązania natywne dla GCP
Microsoft Azure - rozwiązania natywne dla Azure
Third Party Cloud offering - rozwiązania cloud native firm trzecich dostępne w modelu PaaS lub SaaS (najczęsciej dostarczane na zasobach AWS i/lub GCP i/lub Azure)

Zastosowanie / Cel biznesowy	Self manage (on premise or public cloud)	Amazon Web Services	Google Cloud Platform	Microsoft Azure	Third Party Cloud offering
Data Lake (składowanie petabajtów danych jako pliki lub obiekty)	- Hadoop Distributed File System (HDFS) - Apache Ozone (S3 compatible, based on HDFS) - MinIO (S3 compatible) - Alluxio (formerly known as Tachyon, virtual distributed storage system, HDFS, S3, GCS, ABS and other)	- Amazon Simple Storage Service (S3) (HDFS compatible)	- Google Cloud Storage (HDFS compatible)	- Azure Data Lake (gen 2) (HDFS compatible)
Data Catalog, Data Governance, Data lineage etc.	- Hive Metastore - Apache Atlas - Amundsen - Marquez - Datahub - OpenMetadata - EventCatalog	- Amazon Glue Data Catalog	- Google Data Catalog	- Azure Data Catalog
Data LakeHouse	- HDFS + Apache Iceberg (made by Netflix), - HDFS + Apache Hudi (made by Uber), - HDFS + Databricks Delta Lake	(to co w on premise na S3)	(to co w on premise na GCS)	(to co w on premise na ADL)	- Databricks SQL Analytics (preview)
Data Warehouse	- IBM DB2 Warehouse, - Teradata, - Oracle Autonomouse Database / Exadata, - Vertica	- Amazon Redshift	- Google BigQuery	- Azure Synapse (wcześniej Azure SQL Data Warehouse)	- Snowflake (AWS/GCP/Azure)
Data Lake + Data Warehouse integration	- Apache Hive/Apache Spark/etc, - Oracle Big Data SQL, - IBM Db2 Big SQL	- Redshift Spectrum	- Google BigQuery (external tables)	- Azure Synapse (Spark SQL)
Big Data Platforms (Hadoop and Spark)	- Hortonworks Data Platform (HDP) [legacy], - Cloudera Distribution for Hadoop (CDH) [legacy] - Cloudera Data Platform, - HPE Ezmeral (previous MapR), - Apache Bigtop	- AWS EMR	- Google Dataproc	- Azure HDInsight (based on Hortonworks Data Platform) [legacy, killed by Cloudera]	- Databricks Unified Data Analytics Platform (AWS/GCP/Azure), - Cloudera Data Platform Cloud (AWS/Azure)
SQL on DataLake	- Apache Hive, - Apache Spark SQL, - Presto (PrestoDB, Facebook), - Trino (PrestoSQL), - Apache Drill, - Cloudera Impala, - Apache Pig, - Dremio	- AWS Athena (Serverless, based on Presto)	- Google BigQuery (external tables)	- Azure Synapse (Spark SQL)	- Databricks SQL Analytics - Ahana Cloud (Managed Presto on AWS)
SQL relational databases	- PostgreSQL, - MySQL, - Oracle Database, - MS SQL Server	Amazon Relational Database Service (RDS) + Amazon Aurora	Google Cloud SQL	Azure SQL Database Azure Database
SQL Distributed Databases	- CockroachDB	- Amazon Aurora global databases	- Google Cloud Spanner	- Azure Cosmos DB (SQL API)
NoSQL Databases	- Apache HBase (Hadoop Database), - Apache Cassandra / Scylla, - Accumulo	- Amazon DynamoDB, - Amazon Keyspaces (Cassandra as Service),	- Google Bigtable (HBase API)	- Azure CosmosDB (Cassandra API) - Azure Storage Tables	- DataStax Astra (AWS/GCP/Azure)
NoSQL Document Database	- MongoDB	- Amazon DocumentDB	- Google Cloud Datastore	- Azure DocumentDB, - Interfejs API Azure Cosmos DB dla bazy danych MongoDB	- MongoDB Cloud (AWS/GCP/Azure)
NoSQL Grapsh Database	- Neo4j	- Amazon Neptune
NoSQL Cache	- Redis, - Memcache	- Amazon ElastiCache (Redis or Memcached)	- Google Cloud Memorystore	- Azure Redis Cache
NoSQL search engine	- Elastic Stack (Elasticsearch, Kibana, Logstash, etc), - Apache Solr (available in big data distribution)	- Amzon CloudSearch - Amazon Elasticsearch Service (ES)		- Azure Search	- Elastic Cloud (AWS/GCP/Azure)
Brocker	- RabbitMQ - ActiveMQ - ZeroMQ	- Amazon MQ, - Amazon Simple Queue Service (SQS), - Amazon Simple Notification Service (SNS)	- Google Cloud Pub/Sub	- Azure Service Bus + Azure Queue Storage, - Azure Notification Hubs
Streaming - Brocker	- Apache Kafka, - Apache Pulsar	- Amazon Kinesis Data Streams	- Google Pub/Sub,	- Azure Event Hubs
Stream processing	- Apache Spark [Structured] Streaming, - Apache Flink, - Apache Beam, - Kafka Streams, - Apache Storm, - Apache Heron (made by Twitter)	- Amazon Kinesis Data Analytics (based on Apache Flink)	- Google Dataflow (Apache Beam)	- Azure Stream Analytics
Streaming platform	- Confluent Platform (based on Apache Kafka), - Hortonworks/Cloudera DataFlow (based on Apache Kafka and NiFi) - Ververica Platform (based on Apache Flink)	- Amazon Managed Streaming for Apache Kafka (Amazon MSK), - Amazon Kinesis (multiple tools inside)	- Google Dataproc (Big Data platform with Apache Kafka)	- Azure HDInsight (based on Hortonworks DataFlow)	- Confluent Cloud (AWS/GCP/Azure)
Real time data transformation	- Kafka Connect, - Apache NiFi + MiNiFi, - Apache Flume	- Amazon Kinesis Data Firehose	- Google Dataflow (Apache Beam)	- Azure HDInsight (NiFi), - Azure DataFactory
Batch data transformation (ETL, ELT)	- Apache Beam, - Apache Spark, - dbt - Airbyte - Meltano - Apache Hop, - Twister2, - Apache Samza (made by LinkedIN)	- Amazon Glue (serverless Apache Spark) - AWS Data Pipeline	- Google Dataflow (Apache Beam) - Cloud DataPrep (created by Trifacta)	- Azure DataFactory (with support for Databricks/Spark or whole HDInsight platform)
Integration between Relational Database and Data Lake	- Apache Sqoop, - Apache Spark	- AWS Database Migration Service (AWS DMS)		- Azure Database Migration Service
Change Data Capture	- Debezium + Kafka	- AWS Database Migration Service (AWS DMS), - Debezium + Kinesis	- Debezium + Pub/Sub
Task Orchestration	- Apache Airflow, - Apache Oozie (big data distro), - Luigi (Spotify), - Azkaban	- AWS Step Functions - AWS Data Pipeline, - Amazon Managed Workflows for Apache Airflow (MWAA) - Amazon Simple Workflow Service	- Google Cloud Composer (Apache Airflow)	- Azure Data Factory	- Astronomer (Managed Airflow)
Machine Learning and/or Data Science Platform	- Anaconda - Dataiku - H2O.ai	- Amazon SageMaker	- Google Cloud AutoML, - Google Cloud Machine Learning Engine, - Google Cloud Datalab	- Azure Machine Learning, - Azure Machine Learning Studio	- Databricks Unified Analytics Platform - Alteryx
Data Science Notebooks	- Jupyter Family, - BeakerX, - Apache Zeppelin, - Polynote (made by Netflix)	- AWS EMR Notebooks - AWS SageMaker Notebooks	- Google Colaboratory (Colab)	Azure Notebooks (Killed by MS)
Data visualization	- Kibana (Elastic Stack) - Apache Superset - Redash (by Databricks) - Metabase - Tableau - Qlik - Microsoft Power BI (on premise edition)	- AWS QuickSight	- Google Data Studio - Google Looker	- Microsoft Power BI	- Tableau Cloud
Production Ready ML services	(commercial offering by big tech vendors)	- AWS ML Services	- Google Cloud AI Building Blocks	- Azure Cognitive Services

Big Data Technology Warsaw Summit 2023

Fri, 24 Mar 2023 00:00:00 +0000

Mamy przyjemność zaprosić Państwa na 9. edycję Big Data Technology Warsaw Summit.

W tym roku będziemy mieli okazję ponownie spotkać się w Warszawie w dniach 29-30 marca. Oczywiście dla tych pasjonatów Big Data, którzy nie będą mogli przyjechać do Warszawy, jest możliwość pełnego udziału ONLINE w konferencji. Zachęcamy do zapoznania się z poniższymi informacjami i wzięcia udziału w wydarzeniu.

Dlaczego warto dołączyć do Big Data Technology Warsaw Summit stacjonarnie/online?

Ponad 90 wybitnych prelegentów – wizjonerów i ekspertów pracujących z Big Data w czołowych firmach data-driven!
6 praktycznych ścieżek – o najważniejszych aspektach Big Data: Data Engineering, AI and Data Science, Real-time Streaming, Architecture Operations & Cloud, Data Strategy and Roi
20 stolików dyskusyjnych i warsztaty
Prelegenci to uznani eksperci z Polski i zagranicy - inżynierowie, architekci, deweloperzy. Podzielą się doświadczeniem zdobytym podczas pracy nad swoimi projektami w takich firmach jak King, Airbnb, Google, Xebia, Meta, FreeNow i nie tylko
Big Data Technology Warsaw Summit co roku gromadzi ponad 500 uczestników – profesjonalistów w dziedzinie big data. To najlepsze miejsce do wymiany doświadczeń z kolegami z branży!

Podczas konferencji Big Data Technology Warsaw Summit usłyszysz wyciągnięte wnioski i studia przypadków:

Living in Perfect Harmony - Where Music and Machine Learning Meet - Yama Anin Aminof, Data Scientist, Meta
Degenerative feedback loops - how they emerge and why should we care? - Martin Dlask, Data Science Tech Lead, King
Chronon - an open source feature engineering framework - Nikhil Simha, Staff Software Engineer, Airbnb
What data engineering approach and culture fits your organisation better - Pierre de Leusse, Engineering Director, PepsiCo

Szczegółowa agenda znajduje się tutaj.

Jeśli jeszcze nie macie biletu, to z kodem „BDPassion10” możecie skorzystać ze specjalnej 10% zniżki! Rejestracja tutaj.

Praca z CLI w Apache Kafka

Sat, 25 Feb 2023 00:00:00 +0000

Poniżej lista przydatnych poleceń Apache Kafka.

Dla ułatwienia korzystania, używane są odpowiednie zmienne systemowe oraz aliasy.

Jeśli korzystamy z CLI w postaci obrazu Docker ustawmy aliasy jak poniżej:

docker run --rm -it confluentinc/cp-kafka --version
docker run --rm -it confluentinc/cp-kafka kafka-topics --version

alias kafka-topics="docker run --rm -it confluentinc/cp-kafka kafka-topics"

Jeśli jednak wolimy zainstalować Kafka CLI to ściągamy paczkę ze strony Apache Kafka i rozpakowujemy do wybranego katalogu, w moim przypadku ~/programs/kafka/

alias kafka-topics="~/programs/kafka/kafka_2.12-2.8.2/bin/kafka-topics.sh"
alias kafka-console-consumer="~/programs/kafka/kafka_2.12-2.8.2/bin/kafka-console-consumer.sh"
alias kafka-console-producer="~/programs/kafka/kafka_2.12-2.8.2/bin/kafka-console-producer.sh"
alias kafka-consumer-groups="~/programs/kafka/kafka_2.12-2.8.2/bin/kafka-consumer-groups.sh"

Gdy korzystamy z Kafki z zabezpieczonym dostępem (certyfikat lub Kerberos) to w większości poleceniach będziemy potrzebować przekazać konfigurację do polecenia dlatego ustawiamy odpowiednia zmienna

export KAFKA_CLIENT_CONFIG=client.properties

Jesli wszystko działa

kafka-topics --version

export KAFKA_BROKER="localhost:9092"
export TOPIC=test-topic
export GROUP=radek

Topiki

lista:

kafka-topics --bootstrap-server $KAFKA_BROKER --list

kafka-topics --bootstrap-server $KAFKA_BROKER --list \
  --command-config $KAFKA_CLIENT_CONFIG

tworzenie:

kafka-topics --create --bootstrap-server $KAFKA_BROKER --topic $TOPIC

kafka-topics --create --bootstrap-server $KAFKA_BROKER --topic $TOPIC --config cleanup.policy=compact

kafka-topics --create --bootstrap-server $KAFKA_BROKER  --topic $TOPIC --replication-factor 3 --partitions 10

opis:

kafka-topics --describe --bootstrap-server $KAFKA_BROKER

kafka-topics --describe --bootstrap-server $KAFKA_BROKER --topic $TOPIC

kafka-topics --describe --bootstrap-server $KAFKA_BROKER --topic $TOPIC \
  --command-config $KAFKA_CLIENT_CONFIG

kafka-topics --zookeeper $KAFKA_ZOOKEEPER --describe --under-replicated-partitions

kafka-topics --describe --zookeeper $KAFKA_ZOOKEEPER --topic __consumer_offsets

usuwanie

kafka-topics --bootstrap-server $KAFKA_BROKER --delete --topic $TOPIC

Do usuwania należy włączyć tą możliwość w ustawieniach (delete.topic.enable), inaczej tylko oznacza topic jako usunięty.

edycja:

kafka-topics --alter --zookeeper $KAFKA_ZOOKEEPER --topic $TOPIC --partitions 20
kafka-topics --alter --zookeeper $KAFKA_ZOOKEEPER --topic $TOPIC --replication-factor 3
kafka-topics --alter --zookeeper $KAFKA_ZOOKEEPER --topic $TOPIC --replica-assignment 1003:1004:1005,0:1:2,0:1:2,2:1:0

kafka-topics --alter --zookeeper $KAFKA_ZOOKEEPER --topic __consumer_offsets --replication-factor 3

Producent i konsument w konsoli

kafka-console-producer --broker-list $KAFKA_BROKER --topic $TOPIC

kafka-console-producer --broker-list $KAFKA_BROKER --topic $TOPIC --property "parse.key=true" --property "key.separator=|"

cat $TOPIC.json | kafka-console-producer --broker-list $KAFKA_BROKER --topic $TOPIC \
  --property "parse.key=true" --property "key.separator=|"

cat $TOPIC.json | kafka-console-producer --broker-list $KAFKA_BROKER --topic $TOPIC \
  --property "parse.key=true" --property "key.separator=|" \
  --property key.serializer=org.apache.kafka.common.serialization.IntegerSerializer \
  --property value.serializer=org.apache.kafka.common.serialization.StringSerializer \

time for i in {1..10}; do
  echo $i'|{"message": "message'$i'"}' | \
  kafka-console-producer --broker-list $KAFKA_BROKER --topic $TOPIC \
  --property "parse.key=true" --property "key.separator=|"; 
done

time for i in {11..100}; do echo $i'|{"message": "message'$i'"}' | kafka-console-producer --broker-list $KAFKA_BROKER --topic $TOPIC --property "parse.key=true" --property "key.separator=|"; done

kafka-console-consumer --bootstrap-server $KAFKA_BROKER --topic $TOPIC --from-beginning

kafka-console-consumer --bootstrap-server $KAFKA_BROKER --topic $TOPIC --from-beginning \
  --property print.key=true --property print.value=true --property key.separator="|" \
  --consumer.config $KAFKA_CLIENT_CONFIG

kafka-console-consumer --bootstrap-server $KAFKA_BROKER --topic $TOPIC --from-beginning \
  --property print.key=true --property print.value=true --property key.separator="|" \
  --property key.deserializer=org.apache.kafka.common.serialization.IntegerDeserializer \
  --property value.deserializer=org.apache.kafka.common.serialization.StringDeserializer \
  --consumer.config $KAFKA_CLIENT_CONFIG

kafka-console-consumer --bootstrap-server $KAFKA_BROKER --topic $TOPIC --from-beginning \
  --property print.key=true --property print.value=true --property key.separator="|" \
  --property key.deserializer=org.apache.kafka.common.serialization.LongDeserializer \
  --property value.deserializer=org.apache.kafka.common.serialization.StringDeserializer \
  --consumer.config $KAFKA_CLIENT_CONFIG

kafka-console-consumer --bootstrap-server $KAFKA_BROKER \
    --topic test-topic-out \
    --from-beginning \
    --formatter kafka.tools.DefaultMessageFormatter \
    --property print.key=true \
    --property print.value=true \
    --property key.deserializer=org.apache.kafka.common.serialization.StringDeserializer \
    --property value.deserializer=org.apache.kafka.common.serialization.StringDeserializer

kafka-console-consumer --bootstrap-server $KAFKA_BROKER --topic $TOPIC --from-beginning \
  --property print.key=true --property print.value=true --property key.separator="|" \
  | tee -a $TOPIC.json

kafka-console-consumer --bootstrap-server $KAFKA_BROKER --topic $TOPIC --from-beginning \
  --property print.key=true --property print.value=true --property key.separator="|" \
  --consumer.config $KAFKA_CLIENT_CONFIG \
  | tee -a $TOPIC.json

Grupy konsumentów

kafka-consumer-groups --bootstrap-server $KAFKA_BROKER --list

kafka-consumer-groups --bootstrap-server $KAFKA_BROKER --describe --group $GROUP \
    --command-config $KAFKA_CLIENT_CONFIG

kafka-consumer-groups --bootstrap-server $KAFKA_BROKER  --topic $TOPIC  --reset-offsets --to-earliest --group $GROUP \
  --command-config $KAFKA_CLIENT_CONFIG

kafka-consumer-groups --bootstrap-server $KAFKA_BROKER  --topic $TOPIC  --reset-offsets --to-earliest --group $GROUP \
  --execute \
  --command-config $KAFKA_CLIENT_CONFIG

Zarządzanie partycjami

bin/kafka-reassign-partitions.sh --zookeeper $KAFKA_ZOOKEEPER --reassignment-json-file /tmp/increase-replication-factor.json --execute

Uruchamianie i zatrzymywanie

zookeeper:

bin/zookeeper-server-start.sh config/zookeeper.properties

broker:

bin/kafka-server-start.sh config/server.properties

ZooKeeper

instalacja oddzielna:

cd $ZOOKEEPER_HOME
bin/zkCli.sh

wersja z paczki Apache Kafka:

bin/zookeeper-shell.sh $KAFKA_ZOOKEEPER

polecenia konsoli ZooKeepera:

ls /brokers
ls /brokers/ids
ls /brokers/topics
ls /brokers/seqid

Narzędzia

bin/bin/kafka-consumer-groups.sh \
    --topic $TOPIC --zookeeper $KAFKA_ZOOKEEPER \
    --group test_group

DataMass Gdańsk Summit 2022

Fri, 16 Sep 2022 00:00:00 +0000

Do you want to know how to use the cloud to solve Big Data, Data Science, Machine Learning and AI problems?

The next edition of the two-day DataMass Summit conference in Gdansk is coming up!

Don’t wait, join us today! September 29 is a day of workshops led by top practitioners, as well as an evening networking event! On September 30, on the other hand, it’s an all-day onsite conference, with a rich program of speakers - from prominent experts in Big Data, Data Science, Machine Learning and AI, all in the context of cloud solutions!

Improve your knowledge with our speakers:

Running Apache Flink in any cloud environment - Márton Balassi, Apple
Data Infrastructure in a Multi-Cloud environment – Wouter De Bie, Datadog
Spark vs. Bigquery vs. Trino: Shopify’s journey of SQL transformations at scale – Kate Darnell, Shopify
Bank Analytics in the Cloud – Łukasz Hunka, PKO Bank Polski
Engineering Risk Assessment - how to measure the risk in enterprise IT infrastructure – Alicja Grochocka, Investment Banking Sector
Data engineering at the scale of PepsiCo eCommerce, 3 years of experience – Pierre De Leusse, Dmitry Ulyanov, PepsiCo
IoT as a data pipe between the physical world and the cloud AWS - Lukasz Malinowski, Amazon Web Service
Breaking the stormy antipattern - from bad design to cloud native on Beam - Radosław Stankiewicz, Google

And that’s not all! Visit our website - browse the agenda, meet our speakers and find out what else we have in store for you this year!

Join the conference participants and take advantage of the promotion - with the code “BDPASSION10" you will receive a 10% discount! Also, we highly recommend you to register your whole team - if you register 2 or more people, you will receive a 20% discount!

Application for participation here»>

See you in the last week of September in Gdansk!

Infrastructure as Code

Tue, 19 Apr 2022 00:00:00 +0000

tl;dr

Infrastructure as Code (IaC) to:

przeniesienie prac administratora do repozytorium
redukcja błędów i niespójności, większa niezawodność
automatyzacja i integracja z CI/CD - powtarzalność

Kierunek w IT

W ciągu ostatnich kilku lat technologie IT ewoluowały do zróżnicowanych struktur usług, aplikacji, urządzeń, sieci i innych zasobów. Pomiędzy tymi elementami nowoczesnej architektury informatycznej istnieje coraz to większa korelacja via przepływ danych bez względu na różne lokalizacje tych zasobów. Infrastructure as Code to jedna z praktyk do zarządzania takim potencjałem.

Infrastructure as Code (IaC)

IaC to jeden ze sposobów - praktyk tworzenia, modyfikacji i zarządzania zasobami. Definicję można rozbudować o zarządzanie zasobami takimi jak cokolwiek-aaS, IoT, aplikacje, klastry obliczeniowe, usługi, połączenia i urządzenia sieciowe czy to w środowisku on-premise czy w chmurze. Zarządzanie polega na kontrolowaniu zmian w środowiskach poprzez ich opis. Opisem jest oczekiwany stan - do tego wykorzystujemy opis deklaratywny. Podejście deklaratywne to wskazanie właściwości obiektu jakie są dla nas stanem oczekiwanym. Dla kontrastu można wymienić podejście imperatywne, gdzie nie opisujemy jaki efekt chcemy osiągnąć a w jaki sposób - można to opisać jako instrukcja rozkazów. Poniższy schemat obrazuje różnice.

           podejście 
_______________:______________
[deklaratywne] : [imperatywne]
     /\        :        |
    /  \       :       <A>-[B]
  [A]  [B]     :        |
  / \          :   [C]-<D>-[E]
[C] [D]        :    |   |      
    / \        :   [F] [G]
  [F] [G]      :

Modelowanie infrastruktury za pomocą kodu jest naturalnym wynikiem powstawania coraz to większego nacisku na m. in. bezpieczeństwo, powtarzalność, złożoność rozwiązań, dostępność, szybkość wdrażania i redukcji kosztów.

Ta historia może być prawdziwa :)

Wyobraźmy sobie, że przed nami kolejny release i należy zmianę wdrożyć na środowiska (np. dev, sit, uat, etc.) w różnych lokalizacjach (np. regiony w chmurze, urządzenia mobilne, itp.). Sukcesem dokonania tych zmian będzie zautomatyzowanie procesów Continuous Integration, Delivery, Deployment (skrótowo CI/CD) ze wszelkimi dodatkowymi działaniami od strony DevOpsów. CI/CD pokazało, że owe procesy można opisać w repozytorium kodu. Teraz DevOps już wie, że podciągnięcie pozostałych działań do postaci kodu w gicie to wisienka na torcie automatyzacji przepływów pracy. I tak właśnie powstała Infrastructure as Code ;).

Rozwiązanie …

     Infrastructure as Code
   ___________________________
  |      |      |      |      |
(^_^)  [o_o]  (^.^)  (".")  ($.$)

W kontekście naszych rozważań najważniejszym wyzwaniem jest sprostanie budowania bezpiecznych i niezawodnych platform działających na wielu obszarach technologicznych a nawet i prawnych. Dzięki redukcji zagrożeń poprzez możliwość inspekcji i wersjonowania kodu kontrolujemy potrzebę tworzenia i optymalizacji jakości produktu. Wyzwaniem również jest zmieniająca się koncepcja wdrażania i integracji, która była optymalnym rozwiązaniem w chwili jej tworzenia jak i zbieżność środowisk.

0x00 nie dla każdego

Zarządzanie wieloma lokalizacjami / usługami / sieciami / sprzętem / oprogramowaniem itd. to duży nakład pracy podczas tworzenia opisu naszej infrastruktury. Utrzymanie rozbudowanego środowiska wymaga kompleksowej wiedzy i wielopłaszczyznowego doświadczenia inżynierów. Połączenie przeróżnych dostawców sprzętu i usług zewnętrznych (np. dostęp do sieci) i zapewnienie skalowalności tychże rozwiązań to dopiero fundament do dalszych integracji.

▄▄███▄▄·▄▄███▄▄·▄▄███▄▄·
██╔════╝██╔════╝██╔════╝
███████╗███████╗███████╗
╚════██║╚════██║╚════██║
███████║███████║███████║
╚═▀▀▀══╝╚═▀▀▀══╝╚═▀▀▀══╝

Zapewnienie wysokich wartości dla SLA to marzenie każdego, lecz tylko część posiada na to odpowiednie moce w postaci zasobów na ciągłą synchronizację konfiguracji środowisk i wprowadzania nowych elementów.

0xff nie na wszystko

Staramy się ulepszać sposób w jaki pracujemy, podróż wydaje się nie mieć końca i to może być nasz przysłowiowy gwóźdź do trumny.

     _                    _       _          _   _             
  __| | ___  _ __   ___  (_)___  | |__   ___| |_| |_ ___ _ __  
 / _` |/ _ \| '_ \ / _ \ | / __| | '_ \ / _ \ __| __/ _ \ '__| 
| (_| | (_) | | | |  __/ | \__ \ | |_) |  __/ |_| ||  __/ |    
 \__,_|\___/|_| |_|\___| |_|___/ |_.__/ \___|\__|\__\___|_|    
  _   _                                    __           _      
 | |_| |__   __ _ _ __    _ __   ___ _ __ / _| ___  ___| |_    
 | __| '_ \ / _` | '_ \  | '_ \ / _ \ '__| |_ / _ \/ __| __|   
 | |_| | | | (_| | | | | | |_) |  __/ |  |  _|  __/ (__| |_    
  \__|_| |_|\__,_|_| |_| | .__/ \___|_|  |_|  \___|\___|\__|   
                         |_|

Ciągłe prace nad optymalizacją mogą i w większości przypadków prowadzą do błędnego koła, gdyż za każdym razem znajdzie się coś co można zrobić lepiej. Oczywiście należy starać się napisać kod tak dobrze na ile nasz stan wiedzy na to pozwala, lecz czynnikiem istotnym przy tworzeniu takiego bytu jest czas, jakim dysponujemy i trzeba go mieć na uwadze. Zauważyć należy, że multipla to też nie jest idealne auto, ale spełnia swoje zadanie jako pojazd - dość przejaskrawione porównanie ;p.

Ścieżka rozwoju

IaC to racjonalna ścieżka rozwoju nowoczesnego ekosystemu IT, kolejny krok w tworzeniu nowych platform i w rzeczywistości solidny model biznesowy. Zwrócić należy uwagę, że pierwotną ideą tego rozwiązania jest umożliwienie współpracy zespołów zajmujących się programowaniem z rozwojem infrastruktury. Jak tylko do tego dodamy takie idee jak: kod powinien być samodokumentujący się, rozwiązanie powinno być zgodne z duchem KISS, uniwersalność i skalowalność to mamy gotowy przepis na sukces, teoretycznie.

Rzeczywistość jest trochę inna. Zauważamy, że zbyt kompleksowe rozwiązania zabijają produktywność - staramy się z tym walczyć redukując złożoność. Optymalizacja w postaci czytelności kodu - zapewnia to lepszą dokumentację, tutaj stosujemy dobre praktyki, aby narzucić większą klarowność kodu i go ustandaryzować (składnię). Nieustannie dążymy do otrzymania stanu a nie programować - deklaratywne myślenie a więc powtarzalność nie zmienia kodu to oczekiwany stan a droga ku temu potrafi być wyboista. Kolejny ważny element poprawnie działającego kodu to ciągłe testowanie (Continuous Testing). CT jest krytycznym elementem rozbudowanych środowisk, podobnie jak przy każdym releasie oprogramowania i tu należy wystrzegać się błędów konfiguracyjnych, aby uniknąć problemów przy wdrożeniu.

IaC - nie dziękuję

W firmie mamy kilka scenariuszy ustandaryzowanych działań np.: skrypty, notatki w katalogu ICE-produkcja, mamy również zespół ludzi, którzy znają środowisko doskonale, bo pracują tu od 30 lat. Na co dzień radzimy sobie, gdyż nasze systemy nie zmieniły się od dwóch dekad.

Próby wdrożenia podejścia IaC dla takich środowisk jest ogólnie ujmując niemożliwe (teoretycznie realne), gdyż wiąże się to z bardzo dużymi kosztami, które mogą przekroczyć budżet a czas ich realizacji będzie liczony w nieakceptowalnych terminach. Kolejny przesadny przykład, którego przesłaniem jest zobrazowanie, że nie wszystko można automatyzować w duchu Infrastructure as Code. Poniesione koszty nie są adekwatne do korzyści z nich wynikających. Elementy infrastruktury (systemy operacyjne, aplikacje, sprzęt warstwy sieciowej, etc.), które nie są już mocno rozwijane należy pozostawić w spokoju, gdyż próby spisania ich stanów i działań mogą być nieopłacalne. Dodatkowo ich szczątkowe użycie w obecnym świecie może działać niekorzystnie na ich bezpieczeństwo (dbanie o aktualizacje, naprawa na bieżąco błędów), integracje z aktualnymi zasobami (np. porzucenie starych protokołów komunikacji) czy utrzymanie (specjalistów starych technologii ubywa lub są bardzo drodzy).

Narzędzia

Wybór narzędzi jest uwarunkowany zasobami, jakie chcemy spisać. Część z tych aplikacji jest (w różnym stopniu) uniwersalna, może jednocześnie zapisać stan infrastruktury, konfigurację aplikacji czy usług chmurowych. O narzędziach będzie osobny artykuł, lecz tylko wspomnę o kilku, niektóre są specyficznym rozszeżeniem IaC (np. IaC Security)

Nazwa	Link
HashiCorp Terraform	https://www.terraform.io/
RedHat Ansible	https://www.ansible.com/
AWS CloudFormation	https://aws.amazon.com/cloudformation/
Google Cloud Deployment Manager	https://cloud.google.com/deployment-manager/
Puppet	https://puppet.com/
Progress Chef	https://www.chef.io/
VMware SaltStack	http://www.saltstack.com/
(R)?ex	https://www.rexify.org/
Pulumi	https://www.pulumi.com/
Crossplane	https://crossplane.io/
Spectral	https://spectralops.io/
HashiCorp Vagrant	https://www.vagrantup.com/
oak9	https://oak9.io/
HashiCorp Packer	https://www.packer.io/
Microsoft Azure Resource Manager	https://azure.microsoft.com/features/resource-manager/

Best Practice

Lista z ważniejszymi metodami pracy z Infrastructure as Code.

właściwe jest wykonywanie drobnych zmian, gdyż takie działania są łatwiejsze do wycofania się w przypadku natrafienia na błędy
jak już kodujemy to wszystko - starajmy się tylko w wyniku konieczności wykorzystywać źródła zewnętrzne (np. wykonania aplikacji, której wynik można opisać w kodzie)
dokumentujemy jak najmniej, gdyż sam kod odpowiednio zapisany będzie pełnił taką funkcję
staramy się utrzymywać kod w modułach, podział sprzyja rozbudowie i jest klarowny w obsłudze
wskazane jest przechowywanie każdej wersji konfiguracji
skrupulatne testowanie to mniej czasu na obsługę błędów podczas wdrożenia
używaj właściwego narzędzia do tego nad czym zarządzasz
tagowanie w rozbudowanej infrastrukturze jest jak wygrać los na loterii
staramy się, aby nasze szablony były jak najbardziej przydatne w przyszłości do ponownego użycia
nie opieramy wywołań poprzez aplikacje pośrednie bez konieczności takich działań
zadbaj o maksymalną przenośność kodu (np. Multi Cloud)

Confluent Platform - dystrybucja Big Data której sercem jest Apache Kafka

Thu, 14 Apr 2022 00:00:00 +0000

Apache Kafka stała się bazą wielu systemów przetwarzających dane strumieniowe. Jednakże często potrzebujemy rozszerzyć jej możliwości dodatkowymi komponentami jak rejestr schematów, rest proxy, replikację danych, dodatkowe konektory i wiele innych. W takich sytuacjach z pomocą przychodzi nam Confluent Platform, czyli kompletna dystrybucja Big Data, której sercem jest Apache Kafka. Z platformy korzysta obecnie ponad 80% firm z zestawienia Fortune 100. W tym artykule przedstawię najważniejsze informacje dotyczące tej platformy.

Komponenty platformy

Sercem Confluent Platform jest Apache Kafka, oczywiście z uwzględnieniem wszystkich modułów, czyli:

Kafka Core (broker)
Kafka Connect
Kafka Streams

Jednakże największą zaletą korzystania z platformy są dodatkowe komponenty jak:

Confluent Schema Registry — rejestr schematów, który znacząco ułatwia pracę z komunikatami Avro, JSON lub Protobuf
Confluent Clients — biblioteki dostępowe dla języków programowania spoza środowiska JVM jak C/C++, Python, Go, .NET
Confluent REST Proxy — REST API przydatne do pracy, gdy nie możemy skorzystać z natywnych bibliotek klienckich
Confluent Connectors to Kafka — dodatkowe pluginy dla Kafka Connect
ksqlDB — narzędzie umożliwiające strumieniowe przetwarzanie danych oraz budowanie przepływu danych za pomocą języka SQL, bazuje na Kafka Streams oraz Kafka Connect, wcześniejsza nazwa to KSQL
Confluent CLI — dodatkowe narzędzia konsolowe do codziennej pracy z platformą i jej składowymi
Confluent Control Center — narzędzie UI do zarządzania naszym klastrem
Confluent Replicator — narzędzie do replikacji danych pomiędzy klastrami
Confluent Cluster Linking — narzędzie do synchronizacji danych pomiędzy klastrami Apache Kafka (binarnie)
Confluent Auto Data Balancer / Self-Balancing Clusters — narzędzie umożliwiające automatyczne równomierne rozkładanie ruchu na Kafce, wykrywanie awarii oraz automatyczną naprawę klastra
Tiered Storage — optymalizacja kosztów w chmurze przez trzymanie starszych danych np. w Amazon S3, Google Cloud Storage lub MinIO
Confluent JMS Client — Klient JMS dla Kafki
Confluent MQTT Proxy — Możliwość komunikacji z Kafką za pomocą protokołu MQTT (np. RabbitMQ go używa)
Confluent Security Plugins — Dodatkowe pluginy zwiększające bezpieczeństwo

Jak widać, platforma znacząco zwiększa możliwości, jakie oferuje Apache Kafka.

Możliwość wdrożenia

Jeśli chcielibyśmy wypróbować Confluent Platform, najlepszym rozwiązaniem jest skorzystanie z kontenerów dostępnych w Docker Hub.

Gdy przyjdzie nam skorzystać z Confluent Platform produkcyjnie, mamy trzy ścieżki do wyboru

Klasyczna instalacja oparta o maszyny fizyczne (Bare metal) lub wirtualne
Confluent for Kubernetes (CFK) — możliwość instalacji na dowolnym klastrze Kubernetes
Confluent Cloud — gotowy serwis umożliwiający pracę z Confluent Platform w chmurze AWS, GCP lub Azure. Umożliwia on także pracę z Apache Kafka jako serverless.

W przypadku pierwszej wersji, czyli samodzielnej instalacji, można ją przeprowadzić ręcznie za pomocą gotowych paczek ZIP/TAR lub repozytoriów Linux dla systemów Debian, Ubuntu, Red Hat oraz CentOS. Dużo jednak lepszym i wygodniejszym rozwiązaniem jest skorzystanie z gotowych Ansible playbooks.

Licencja i cennik

Confluent Platform korzysta z trzech rodzajów licencji:

Apache 2.0 License — Apache Kafka, Kafka Streams, Kafka Connect, Kafka Clients, Serializers, Community Connectors
Confluent Community License — REST Proxy, Schema Registry, ksqlDB, Confluent Connectors
Confluent Enterprise License — Control Center, Replicator, Auto Data Balancer, Enterprise Connectors

Z narzędzi dostępnych na licencji Apache 2.0 może skorzystać każda firma. Jeśli jesteśmy firmą, która chce wykorzystać Confluent Platform do własnego użytku, to najprawdopodobniej możemy skorzystać za darmo także z rozwiązań objętych licencją community (szczegóły w treści licencji). Firmy chcące skorzystać ze wszystkich możliwości, jakie oferuje Confluent Platform, muszą liczyć się z koniecznością zakupu pełnej komercyjnej licencji, wraz z którą otrzymują wsparcie firmy Confluent. Cennik nie jest publicznie dostępny, dlatego w przypadku zainteresowania proszę o kontakt z przedstawicielami firmy.

W przypadku wersji chmurowej mamy możliwość pracy z platformą w modelu płatności za użycie, zaś cennik jest publicznie dostępny na stronie Confluent Cloud.

Dodatkowe informacje

W kolejnych artykułach przyjrzymy się bliżej możliwościom, jakie oferuje Confluent Platform.

Więcej informacji można także znaleźć pod poniższymi adresami:

Instalacja CDP za pomocą Cloudera Managera on premise

Wed, 06 Apr 2022 00:00:00 +0000

Instrukcja instalacji Cloudera Data Platform (CDP) + Cloudera Manager (CM) na CentOS w środowisku nieprodukcyjnym w celu prezentacji lub jako proof-of-concept. Instalujemy Cloudera Manager z JDK, bazą PostgreSQL, usługą Manager Server, Manager Agent i Cloudera Runtime.

W artykule mamy opis platformy za pomocą dwóch skrótów, które określają platformę do zarządzania danymi.

Skrót	Opis
CDP	Cloudera Data Platform
CDH	Cloudera Distribution Hadoop

Termin CDH określa Cloudera’s Open Source Platform Distrbution including Apache Hadoop. Podczas instalacji niektóre nazwy pakietów w repozytoriach mają tajemnicze cdh7 w nazwie. Wynika to z pewnych powodów technicznych powiązanych z upgradeami. Generalnie mówimy o CDP i możemy przyjąć, że cdh7=cdp :)

Kolejny skrót to CM tj. orchestrator klastrów Big Data, posiada zautomatyzowane procedury pomocne przy pracy na co dzień dla administartorów.

Koncepcja

Naszym środowiskiem będzie 9 maszyn postawionych on premise. Pierwsza maszyna będzie pełniła funkcję zarządcy a pozostałe to składniki klastra. Kolejna porcja skrótów:

DN Data Node - węzły przechowujące dane (bloki z danymi)
NN Name Node - węzeł zarządzający ww danymi

                 [Cloudera Manager]
                         |
           [NameNode + pozostałe_serwisy]
                         |
      ----------------------------------------
      |     |      |     |      |     |      |
 [DataNode] | [DataNode] | [DataNode] | [DataNode]
            |            |            |
       [DataNode]   [DataNode]   [DataNode]

___________________________________________________
 Schema Powered by Vim The power tool for everyone

Przygotowanie Systemu Operacyjnego

Ze strony projektu CentOS pobieramy obraz iso do instalacji. Link do wyboru architektury i typu https://www.centos.org/download/. Bezpośredni link: http://isoredirect.centos.org/centos/7/isos/x86_64/ również zaszyty w kodzie QR poniżej.

Wspierana wersja CentOS

Tabelka przedstawia jaki system operacyjny jest kompatybilny z wersją Cloudery

	CentOS	Wersja CDP
	7.9, 7.8, 7.7, 7.6, 7.5, 7.4, 7.3, 7.2	7.3.x
!	7.9, 7.8, 7.7, 7.6, 7.5, 7.4, 7.3, 7.2	7.2.x
	7.6, 7.5, 7.4, 7.3, 7.2	7.1.x
	7.6, 7.5, 7.4, 7.3, 7.2	7.0.x

Wykrzyknik wskazuje z jakiej wersji CM/CDP będziemy korzystać.

Wspierane systemy plikow pod HDFS-a

ext3
ext4
xfs

Wersja jvm

	CDP	Oracle JDK	OpenJDK
	7.3.x	1.8	1.8, 11.0.3+
!	7.2.x	1.8	1.8, 11.0.3+
	7.1.x	1.8	1.8, 11.0.3+
	7.0.x	1.8	1.8, 11.0.3+

Zalecaną wersją jest OpenJDK 1.8u212. Należy pamiętać, że wersje JDK 7 i niższe nie są wspierane dla CM 6.x i CDP 6.x.

Wykrzyknik wskazuje z jakiej wersji CM/CDP będziemy korzystać.

https://supportmatrix.cloudera.com/

Kompatybilność wersji CDP i CM

Aplikacje mają konwencję nazewnictwa wersji: <major>.<minor>.<maintenance>. Wersja <major>.<minor> Cloudera Managera musi być identyczna lub wyższa z wersją CDP, wersja <minor> jest tu pomijana.

Przykłady:

CM	ok?	CDP
7.0.9	[x]	7.0.0
7.1.9	[x]	7.0.0
7.2.9	[x]	7.0.1
7.2.9	[x]	7.2.0
7.2.9	[x]	7.1.9
7.2.9	[ ]	7.3.9

Wymagania sprzętowe

Dla naszego środowiska (to jest lab = usługa nieprodukcyjna) założyliśmy, że każda maszyna musi mieć

Dysk 40 GB
8 vCPU
RAM 24 GB
DN 8 x 2 GB

Generowanie i dystrybucja kluczy ssh

Po instalacji OS logujemy się na pierwszą maszynę i tworzymy parę kluczy do połączeń po ssh. Najszybciej wykonać to poleceniem ssh-keygen, właściwe polecenie:

/usr/bin/ssh-keygen -t rsa

Za pomocą skryptu ssh-copy-id zawartość pliku id_rsa.pub dopiszemy do pliku authorized_keys na pozostałych maszynach. Na pierwszym (pierwszy) hoście możemy tego dokonać wykonując polecenie

[root@hadoop160 ~]# cat ~/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys

Nim prześlemy nasz klucz publiczny na inne hosty to sprawdzamy czy możemy nawiązać połączenie za pomocą ssh do samych siebie a więc logując się do tej samej maszyny na której jesteśmy.

[root@hadoop160 ~]# ssh 0
The authenticity of host '0 (0.0.0.0)' can't be established.
ECDSA key fingerprint is SHA256:LDxMU+4lcrblD9c/VsUznP4adzI5Rc+sp6wFiJNUn5A.
ECDSA key fingerprint is MD5:6f:a2:20:97:1c:2d:e4:31:cd:4e:4d:f9:a4:15:e1:90.
Are you sure you want to continue connecting (yes/no)? yes
Warning: Permanently added '0,0.0.0.0' (ECDSA) to the list of known hosts.
Last login: Tue Dec 21 16:59:22 2021 from 192.168.133.250

Jeśli mamy podobny wynik to używamy skryptu ssh-copy-id do wykonania tego samego zadania tylko na innych hostach.

Należy zwrócić uwagę, że domyślnie systemy modern linux mają wyłączoną możliwość zdalnego logowania się jako administrator (przeważnie jest to użytkownik root). Rozwiązaniem może być logowanie się jako inny użytkownik a następnie podniesienie swoich uprawnień za pomocą polecenia sudo lub dopisanie w /etc/ssh/sshd_config linijki PermitRootLogin yes i restart usługi systemctl restart sshd.

DHCP w sieci

Protokół IP wersji 6 nie jest wspierany i musi być wyłączony.

W naszym środowisku musimy zadbać o niezmienność adresu IP z nazwą domenową każdego z hostów, gdyż każdy nod (węzęł) w klastrze identyfikuje się nazwą domenową. Najprostszym rozwiązaniem będzie przypisanie na stałe adresów IPv4 dla sieci w której będzie działać Hadoop. W naszym przypadku należy utworzyć plik net-172.31.184-24.xml, treść poniżej.

<network connections='1'>
  <name>net-172.31.184-24</name>
  <uuid>00000000-0172-0031-0184-000000000000</uuid>
  <forward mode='nat'>
    <nat>
      <port start='1024' end='65535'/>
    </nat>
  </forward>
  <mac address='40:00:ac:1f:b8:fa'/>
  <ip address='172.31.184.250' netmask='255.255.255.0'>
    <dhcp>
      <range start='172.31.184.240' end='172.31.184.249'/>
      <host mac='40:00:ac:1f:b8:01' name='hadoop001' ip='172.31.184.1'/>
      <host mac='40:00:ac:1f:b8:02' name='hadoop002' ip='172.31.184.2'/>
[...]
    </dhcp>
  </ip>
</network>

a następnie go zaimportować za pomocą polecenia

root@bigdatalab:~# virsh net-define net-172.31.184-24.xml 
Network net-172.31.184-24 defined from net-172.31.184-24.xml

Tabelka przedstawia właściwą konfiguracje klastra w 2/3 warstwie sieci:

Rola	MAC adres	nazwa hosta (fqdn)	adres IPv4
Manager	40:00:ac:1f:b8:9f	hadoop159.bigdatalinux.org	172.31.184.159
Worker	40:00:ac:1f:b8:a0	hadoop160.bigdatalinux.org	172.31.184.160
Worker	40:00:ac:1f:b8:a1	hadoop161.bigdatalinux.org	172.31.184.161
Worker	40:00:ac:1f:b8:a2	hadoop162.bigdatalinux.org	172.31.184.162
Worker	40:00:ac:1f:b8:a3	hadoop163.bigdatalinux.org	172.31.184.163
Worker	40:00:ac:1f:b8:a4	hadoop164.bigdatalinux.org	172.31.184.164
Worker	40:00:ac:1f:b8:a5	hadoop165.bigdatalinux.org	172.31.184.165
Worker	40:00:ac:1f:b8:a6	hadoop166.bigdatalinux.org	172.31.184.166
Worker	40:00:ac:1f:b8:a7	hadoop167.bigdatalinux.org	172.31.184.167

Instalacja wymaganych składników OS i narzędzi

Aktualizacja OS i instalacja narzędzi

yum update  -y
yum -y upgrade
yum install -y epel-release
yum install -y wget htop ntp byobu ncdu python-psycopg2

Host Name i wpisy w pliku hosts

172.31.184.159 hadoop159.bigdatalinux.org hadoop159
172.31.184.160 hadoop160.bigdatalinux.org hadoop160
172.31.184.161 hadoop161.bigdatalinux.org hadoop161
172.31.184.162 hadoop162.bigdatalinux.org hadoop162
172.31.184.163 hadoop163.bigdatalinux.org hadoop163
172.31.184.164 hadoop164.bigdatalinux.org hadoop164
172.31.184.165 hadoop165.bigdatalinux.org hadoop165
172.31.184.166 hadoop166.bigdatalinux.org hadoop166
172.31.184.167 hadoop167.bigdatalinux.org hadoop167

for i in "" --pretty --static --transient ; do
hostnamectl set-hostname hadoop159.bigdatalinux.org ${i} ; done

Synchronizacja czasu (ntp)

yum install -y ntp
systemctl start ntpd
systemctl enable ntpd

Sprawdzamy stan synchronizacji poleceniem ntpstat lub ntptime.

Coraz częściej zaleca się używanie chrony. Więcej pod adresem https://chrony.tuxfamily.org/

Security-Enhanced Linux + Firewall

SELinux nie powinien blokować działać CDP i CM. Na potrzeby naszego laba będzie on wyłączony. Rzecz ma się podobnie dla iptables (usługi firewalld) żadne regułki filtrowania sieciowego nie będą włączone.

SELinux

Zauważmy, że plik /etc/sysconfig/selinux wskazuje (jest linkiem) na /etc/selinux/config, więc zmiany możemy dokonac w jednym miejscu.

sed -i 's/SELINUX=enforcing/SELINUX=disabled/g' /etc/selinux/config

Przed zmianą było SELINUX=enforcing a po zmianie SELINUX=disabled. Jeśli nie chcemy restartować systemu operacyjnego to możemy wykonać polecenie setenforce 0 a następnie sprawdzić poleceniem getenforce (oczekiwany wynik: Permissive). W przypadku rebootu getenforce zwróci Disabled.

Firewalld

W pierwszym poleceniu wyłączamy autostart usługi przy starcie systemu. W drugim poleceniu zatrzymujemy ją a w ostatnim sprawdzamy w poszukiwaniu oczekiwanego statusu Active: inactive (dead).

systemctl disable firewalld
systemctl stop firewalld
systemctl status firewalld

Pobieramy instalator CM

Będąc zalogowanym na maszynie zarządzającej (tu hadoop159.bigdatalinux.org) pobieramy a następnie uruchamiamy instalator Cloudera Managera

wget https://archive.cloudera.com/cm7/7.4.4/cloudera-manager-installer.bin
chmod a+x cloudera-manager-installer.bin
./cloudera-manager-installer.bin

W celu odinstalowania należy uruchomić skrypt /opt/cloudera/installer/uninstall-cloudera-manager.sh.

Instalacja CM

Akceptujemy warunki licencji

Po kilkuminutowej instalacji usługi CM

zostaje wyświetlony komunikat. Informuje o danych do zalogowania się do CM. Login to admin i hasło również admin. W przeglądarce wskazujemy adres IP maszyny i port 7180.

Tutaj http://172.31.184.159:7180

Pozostaje wybrać sposobu korzystania z Cloudera Manager. Do wyboru

import licencji Upload Cloudera Data Platform License
60 dniowy trial Try Cloudera Data Platform for 60 days

Wybieramy Try Cloudera Data Platform for 60 days a następnie akceptujemy postanowienia licencji zaznaczając Yes, I accept the Cloudera Standard License Terms and Conditions..

Tworzenie klastra

Krok 1

Domyślnie pojawi nam się wizard, który pomoże przy tworzeniu nowego klastra. Po wyświetleniu się tytułu Add Traditional Bare Metal Cluster przechodzimy dalej klawiszem Continue. Wpisujemy nazwę klastra bigdatapassion i ponownie wybieramy Continue.

Krok 2

Wskazujemy hosty, które będą w klastrze CDP. Możemy tu w każdej linijce wkleić nazwę domenową każdego noda lub użyć wzorca hadoop16[0-7].bigdatalinux.org. Taka konstrukcja doda 8 nodów. Po wpisaniu nazwy hostów należy wybrać klawisz Search a po wyświetleniu się oczekiwanych maszyn i tu wybieramy Continue.

Krok 3

Na kolejnym ekranie wybieramy skąd będą pobierane repozytoria. Dla Repository Location używamy Cloudera Repository (Requires direct Internet access on all hosts.). Reszta pozostaje bez zmian.

Krok 4

Mamy 3 możliwości zainstalowania Java Development Kit (JDK).

1. instalacja ręczna (np. za pomocą playbooka ansible) - Manually manage JDK
1. instalacja zalecanej wersji przez CM - Install a Cloudera-provided version of OpenJDK
1. instalacja z repo OS - Install a system-provided version of OpenJDK

Wybierzemy opcję numer 2 a więc Cloudera zainstaluje zalecaną wersję OpenJDK

Krok 5

Podczas instalacji Cloudery wymagany jest dostęp do konta root na każdym węźle. Zadbaliśmy o to podczas tworzenia klucza i jego dystrybucji na pozostałe hosty. SSH Username pozostaje bez zmian (tj. root). Musimy wskazać klucz prywatny i go uploadować. Z Authentication Method wybieramy 2. opcję All hosts accept same private key. Pojawi się możliwość wrzucenia pliku klucza prywatnego (nazwa: id_ed25519).

Krok 6

Po zakończeniu instalacji agentów na każdym węźle w statusie otrzymamy Installation completed successfully i podświetli się klawisz Continue i przechodzimy do kolejnego kroku.

Krok 7

W nowej zakładce można podejrzeć już jakieś informacje o hostach http://172.31.184.159:7180/cmf/hardware/hosts.

Krok 8

W dwóch testach dokonujemy sprawdzenia jakości połączeń sieciowych i kondycji komponentów klastra.

Problem może wystąpić z nadmiernym używaniem swapu i włączonym Transparent Huge Page.

Pierwsze naprawiamy poleceniem (na każdym hoście)

echo "vm.swappiness=1" >> /etc/sysctl.conf

a kolejne

echo never > /sys/kernel/mm/transparent_hugepage/defrag
echo never > /sys/kernel/mm/transparent_hugepage/enabled

Jeśli nie dokonamy rekomendowanych zmian należy wybrać I understand the risks of not running the inspections or the detected issues, let me continue with cluster setup.

Instalacja składników klastra

Z menu głównego po lewej stronie rozwijamy Cluster a w nim mamy 2 sposoby dodania usług do nowo utworzonego klastra.

Wybieramy Add Services, wtedy uruchomimy wizard a w nim mamy kilka predefiniowanych zestawów aplikacji.
Gdybyśmy wybrali nazwę utworzonego klastra tj. bigdatapassion przechodzimy do ekranu w którego górnej części jest rozwijane menu Actions gdzie i tu mamy możliwość wybrania składników klastra obliczeniowego pod przyciskiem Add service.

Po wybraniu Add Services mamy 7 kroków

Krok 1 - wybór usług

Do wyboru 3 gotowe konfiguracje lub własna kompozycja usług

Data Engineering
Data Mart
Operational Database
Custom Services (*)

Wybierając ostatnią możliwość zainstalujemy tylko hadoopowy system plików (HDFS) i wybierzemy Continue.

Krok 2 - przypisanie hostów do roli

Ponieważ wszystkie 8 hostów ma taką samą konfigurację sprzętową (ilość podpiętych zasobów dyskowych) to wybieramy, że wszystkie nody będą DN a więc węzłami, które będą odpowiedzialne za przechowywanie danych na HDFS-ie. Pierwszy host będzie pełnił rolę NN a więc usługi zarządzającej rozmieszczeniem danych na DN.

Wybieramy okienko pod DataNode x 7 New i z menu rozwijanego All Hosts (alternatywnie: Custom... i tu checkboksami zaznaczamy wszystkie wiersze). Parametry pozostałem dla roli HDFS jak i Cloudera Management Service pozostają bez zmian.

Krok 3 - podłączenie do bazy danych

Wskazujemy z jakiej bazy danych usługa Reports Manager ma korzystać. Wybór jest pomiędzy:

uruchomioną już bazę danych (zainstalowaną na zarządcy a więc na maszynie hadoop159.bigdatalinux.org - tam gdzie działa Cloudera Manager
własną zainstalowaną ręcznie / uruchomioną na innym hoście.

Do wyboru mamy 3 rodzaje

MySQL
PostgreSQL
Oracle

Dane autoryzacji do DB na maszynie zarządzającej są wyświetlane w interfejsie webowym, można je również odczytać z pliku /etc/cloudera-scm-server/db.mgmt.properties

grep "REPORTSMANAGER" /etc/cloudera-scm-server/db.mgmt.properties

com.cloudera.cmf.REPORTSMANAGER.db.type=postgresql
com.cloudera.cmf.REPORTSMANAGER.db.host=hadoop159.bigdatalinux.org:7432
com.cloudera.cmf.REPORTSMANAGER.db.name=rman
com.cloudera.cmf.REPORTSMANAGER.db.user=rman
com.cloudera.cmf.REPORTSMANAGER.db.password=tXHf3CYkcp

Zastosujemy domyślne rozwiązanie i wykorzystamy już istniejącą bazę. Koniecznym krokiem jest Test Connection a wtedy podświetli się Continue.

Krok 4 - dodatkowe ustawienia

Dla naszego wyboru nie ma tu żadnej dodatkowej konfiguracji.

Krok 5 - podgląd planowanych zmian

Na tym ekranie dokonujemy zmiany usuwając dysk systemowy jako miejsce przechowywania danych na HDFSie. W DN Data Directory usuwamy pierwszy wpis /dfs/dn.

Krok 6 - uruchomienie usług

Proces powinien potrwać ok. minuty a stanem oczekiwanym jest Status: Finished.

Krok 7 - podsumowanie

Podsumowanie

Otrzymujemy ekran z wykresami.

Uwagi

Monitorowanie - zmiana progów ostrzeżeń

Konfiguracja z dyskami dla przechowywania danych dla DN wielkości 2 GB to tylko PoC, właściwa wielkość powinna być wyrażona w jednostkach TB. Domyślnie CM wyświetla ostrzeżenie/błąd, gdy jest mniej niż 5/10 GB wolnego miejsca na potrzeby HDFSa.

Rozwiązanie tej niedogodności to zmiana wartości progowych monitu o małej ilości wolnej przestrzeni każdego DN.

Rozwiązanie 1 - API

Za pomocą API dokonujemy zmian dla dwóch grup (tworzą się domyślnie)

hdfs-DATANODE-BASE
hdfs-DATANODE-1

PUT /api/v31/clusters/bigdatapassion/services/hdfs/roleConfigGroups/hdfs-DATANODE-BASE/config
{
  "items": [
    {
      "name": "datanode_data_directories_free_space_absolute_thresholds",
      "value": "{\"warning\":1073741824,\"critical\":536870912}"
    }
  ]
}

PUT /api/v31/clusters/bigdatapassion/services/hdfs/roleConfigGroups/hdfs-DATANODE-1/config
{
  "items": [
    {
      "name": "datanode_data_directories_free_space_absolute_thresholds",
      "value": "{\"warning\":1073741824,\"critical\":536870912}"
    }
  ]
}

Rozwiązanie 2 - WebUI

Z menu po lewej stronie wybieramy Clusters a następnie nazwę naszego klastra, tu bigdatalinux. Z menu Configuration przechodzimy do Configurationt Search. W polu wyszukiwania wyszukujemy datanode directory free space - interesuje nas DataNode Data Directory Free Space Monitoring Absolute Thresholds. W przeciwieństwie do poprzedniego rozwiązaniu tu można wykonać zmianę za pomocą zmiany parametrów jednocześnie dla dwóch grup. Wystarczy zapisać zmianę (z ewentualnym komentarzem) za pomocą Ctrl+S i poczekać kilka minut za aktualizacją statusu.

Oczekiwany stan

Po wybraniu z menu Clusters po lewej stronie roli HDFS w pierwszej zakladce Status ujrzymy wykres Health wskazujący kiedy nastąpiła zmiana statusu.

Umarł król, niech żyje król, czyli czym zastąpić dystrybucję Hortonworks

Mon, 28 Mar 2022 00:00:00 +0000

Przez długi czas, Hortonworks Data Platform oraz Hortonworks DataFlow były najpopularniejszymi dystrybucjami Big Data na świecie. Ze względu na możliwość korzystania z platformy całkowicie za darmo bez potrzeby jakiejkolwiek rejestracji, tak naprawdę nie wiadomo jako dużo projektów było o nią opartych, ale widząc choćby popularność w internecie w samej Polsce było ich sporo. Niestety dla tych wszystkich firm i projektów, firma Hortonowrks już nie istnieje, zaś sama platforma nie jest już rozwijana.

Stało się to za sprawą połączenia firmy Hortonworks z firmą Cloudera 1 stycznia 2019 roku.

Od tamtego czasu minęły już ponad trzy lata, a mimo to wiele firm nadal korzysta z rozwiązań zbudowanych przez firmę Hortonworks jak Hortonworks Data Platform oraz Hortonworks DataFlow.

Przyczyn tego zjawiska jest wiele, najczęściej są to braki kadrowe, niechęć do ponoszenia nowych wydatków związanych z migracją, trudność samej migracji, gdyż na obecnej platformie jest opartych wiele produkcyjnych systemów oraz po prostu trudność wyboru nowej platformy.

Niestety 31 grudnia 2021 zakończył się okres wsparcia dla platformy Hortonworks Data Platform, co oznacza, że najwyższy czas pomyśleć o migracji.

Sytuacja jest o tyle ciekawsza, że także część serwisów chmurowych jest także oparta o wspomniane platformy jak na przykład:

Microsoft Azure HDInsight
Oracle Cloud Big Data Service
IBM Analytics Engine
OVH Analytics Data Platform

Dlatego powyższym dostawcom usług chmurowych, jak i ich klientom, także będzie zależeć na zastąpieniu tych platform ich nowszymi wersjami.

W artykule spróbuję wskazać kilka najpopularniejszych dróg migracji platform firmy Hortonworks.

Artykuł ten dedykuje Apache Ambari, które przez wiele lat pomagało budować, zarządzać i monitorować klastry Big Data. Niestety jako integralna część platform firmy Hortonworks, 10 stycznia 2022 roku zdecydowano o zamrożeniu repozytorium kodu i przekazaniu projektu do Attic.

Migracja do Cloudera Data Platform

Po połączeniu firmy Hortonworks wraz z firmą Cloudera podjęto decyzję, że firma udostępni swoim klientom swoją nową platformę, która nazywa się Cloudera Data Platform (CDP). W praktyce CDP jest to mocno rozwinięta wersja poprzedniej platformy firmy, czyli Cloudera Distribution for Hadoop (CDH) gdzie dołożone kilka komponentów z dystrybucji Hortonworks jak np. Apache Ranger, który zastąpił Apache Sentry (także przekazane do Attic). Porównanie funkcjonalności HDP z CDP można znaleźć tutaj.

Cloudera Data Platform jest dostępna w trzech wersjach:

CDP Private Cloud Base - wersja “tradycyjna” oparta o maszyny fizyczne lub wirtualne, wersja najbliższa architekturą platformie HDP
CDP Private Cloud - wersja oparta o klastry Kubernetes, obecnie wspierany jest Red Hat OpenShift (co może zostać rozszerzone w przyszłości)
CDP Public Cloud - wersja dla firm chcących korzystać z platformy Cloudery w chmurze na zasobach AWS, GCP lub Azure, jest to gotowy serwis zarządzany przez Clouderę

Dużym plusem dla użytkowników Hortonworks Data Platform (oraz także CDH) jest przygotowany i udokumentowany proces migracji do CDP zarówno z wersji 2.x oraz najnowszej 3.x.

Dużą różnicą w stosunku do dystrybucji Hortonworks jest konieczność zakupu licencji, około 10 tysięcy dolarów rocznie za serwer, chętnych odsyłam do cennika.

Migracja do konkurencyjnej platformy

Cloudera nie jest jedyną firmą, która postanowiła ułatwiać firmom pracę z technologiami Big Data, dlatego też można rozważyć skorzystanie z oferty innej firmy. Oczywiście oferty tych firm są różne i nie stanowią kompletu funkcjonalności Cloudera Data Platform lub niekiedy musimy skorzystać z kilku, by zrealizować wszystkie wymagania naszego biznesu.

Najbliższym rozwiązaniem może okazać się HPE Ezmeral Data Fabric. Osoby dłużej związane z rynkiem Big Data mogą tę platformę kojarzyć pod wcześniejszą nazwą, czyli MapR, gdyż Hewlett Packard Enterprise ogłosił 5 sierpnia 2019 kupno firmy MapR Technologies i jej platformy. W przypadku tej platformy także możemy wybrać instalację w oparciu o maszyny fizyczne bądź wirtualne oraz także klaster Kubernetes. Możemy także skorzystać z oferty “private cloud” od HPE zwanej GreenLake.

Do innych popularnych platform z obszaru Big Data należą między innymi:

Confluent Platform - gdy potrzebujemy klastrów Apache Kafka
Ververica Platform - jeśli chcemy oprzeć nasz streaming o Apache Flink
Starburst Enterprise - dla firm korzystających z Trino
Elastic Stack - gdy interesuje nas enterprise search i podobne zastosowania, w tym także wizualizacja
DataStax Enterprise - platforma oparta o Apache Cassandra, klastry Kubernetes oraz Apache Pulsar (Luna Streaming)

Własna platforma

Platformy firmy Hortonworks nie były tylko darmowe, ale także w stu procentach otwartoźródłowe. Biorąc to pod uwagę, możemy rozważyć także budowę własnej platformy, wykorzystując popularne narzędzia jak Hadoop, Spark, Kafka, Flink czy Airflow. Zarządzanie taką platformą, zamiast Ambari i Cloudera Manager, możemy oprzeć o popularne narzędzia takie jak Ansible lub Puppet.

Do zbudowania własnej dystrybucji, możemy także skorzystać z bazowej dystrybucji Apache Bigtop. Na jej podstawie powstaje choćby bardzo popularny AWS EMR.

Ta droga likwiduje potrzebę kupowania drogich licencji i wsparcia, jednak wymaga zbudowania zgranego zespołu specjalistów, którzy stworzą i utrzymają taką własną platformę Big Data.

Chmura publiczna

Jednym z popularnych trendów, zwłaszcza w platformach analitycznych, jest migracja do chmury publicznej. Każdy z większych dostawców chmurowych udostępnia szereg natywnych rozwiązań big data, w tym data science i machine learning. Sprawia to, że praca z danymi w chmurze jest prosta, szybka i przyjemna. Dodatkowo chmury oferują niezwykłą dostępność zasobów, niespotykaną wręcz w środowiskach on premise, gdzie na dodatkowy sprzęt możemy czekać niekiedy miesiącami. Chmura potrafi także być tańsza, szczególnie przez korzystanie z automatycznej skalowalności i płatności tylko za użyte zasoby w czasie. Nie musimy inwestować na start w olbrzymi klaster kilkudziesięciu maszyn i poświęcać wielu tygodni lub miesięcy na jego wdrożenie w organizacji, lecz od pierwszych chwil możemy zająć się już realną pracą z danymi. Nie musimy także zaczynać od nie wiadomo jak dużych wolumenów danych, by nam się opłacało sięgać po te technologie, gdyż próg wejścia jest wyjątkowo niski w chmurze publicznej.

W chmurze możemy korzystać z dystrybucji Big Data takich jak Amazon EMR czy Google Dataproc rozwijanych przez dostawców chmurowych oraz także dystrybucji firm trzecich jak Databricks’ Unified Data Analytics Platform stworzoną przez firmę Databricks i dostępną w AWS, GCP oraz Azure. Należy jednak pamiętać, że część serwisów Big Data, jak np. Azure HDInsight bazuje na rozwiązaniach Hortonworks, dlatego jako nowy klient, lepiej skorzystać z alternatywnych rozwiązań.

Więcej o zaletach pracy z danymi w chmurze można znaleźć w mojej prezentacji.

Docker i Kubernetes

Na koniec jeden z najnowszych trendów, czyli wykorzystanie projektów takich jak Docker i Kubernetes do budowy własnej platformy analitycznej. Do tej pory większość dystrybucji Big Data była oparta o maszyny fizyczne lub wirtualne. Jednak w erze niesamowitej popularyzacji kontenerów, coraz więcej rozwiązań IT jest przenoszonych do tego świata. Tak też się dzieje z technologiami Big Data.

Dobrym przykładem jest firma Uber, która przeniosła swój Data Lake oparty o Apache Hadoop do kontenerów. Także twórcy wielu popularnych narzędzi Big Data jak Spark, Flink lub Kafka Streams wspierają pracę na klastrach Kubernetes. Wspomniane wcześniej komercyjne platformy Big Data jak AWS EMR lub Cloudera Data Platform są dostępne zarówno w wersji opartej o klasyczne wdrożenie na maszyny wirtualne / fizyczne jak i w oparciu o Kubernetes. Databricks, czyli firma stojąca za rozwojem Apache Spark, swoją bardzo popularną platformę chmurową w wersji Google Cloud oparła o Google Kubernetes Engine. Także ich najnowsza usługa, czyli Databricks Serverless SQL, jest oparta o Amazon Elastic Kubernetes Service (EKS) (w momencie pisania artykułu serverless SQL jest dostępny jako preview tylko w chmurze AWS).

Podsumowanie

Jak widać powyżej, połączenie się firm Hortonworks i Cloudera zmusiło wiele firm do przemyślenia na nowo swojego podejścia do budowy platformy analitycznej. Na szczęście, możliwości rynek oferuje sporo, powyżej wymieniłem w skrócie 5 najpopularniejszych kierunków widocznych w polskim i światowym community. Każda z powyższych ścieżek niesie z sobą pewne zalety i wady, ostateczną decyzję zatem każda firma będzie musiała podjąć samodzielnie na podstawie swoich potrzeb i możliwości.

Big Data Technology Warsaw Summit 2022

Wed, 23 Mar 2022 00:00:00 +0000

Miło nam poinformować, że Big Data Technology Warsaw Summit powraca do Warszawy!

W tym roku konferencja będzie dostępna w dwóch odsłonach, stacjonarnej w Warszawie dla tych co chcieliby się spotkać twarzą w twarz (także z nami) oraz wersję online dla tych którzy nie mogą przybyć osobiście.

Dlaczego warto uczestniczyć w Big Data Technology Warsaw Summit onsite/online?

To jedyna w Polsce tak duża technologiczna i międzynarodowa konferencja, skupiona na dużych danych
Prelegenci to wybitni eksperci z Polski i zagranicy – inżynierowie, architekci, deweloperzy. Podzielą się doświadczeniem zdobytym przy wyjątkowo ciekawych projektach – m.in. w takich firmach jak: Allegro, Apple, Bank Millennium, eBay, Google Cloud, Microsoft, OLX Group, Philip Morris International, Reckitt, Ringier Axel Springer Polska, T-Mobile PL, Vertica, Zalando.
Konferencja jest w najwyższym stopniu praktyczna i technologiczna. Poznacie case studies oraz najnowsze rozwiązania w takich dziedzinach jak:
- Architecture Operations & Cloud
- Data Strategy and Roi
- Data Engineering
- AI and Data Science
- Real-Time Streaming
Big Data Technology Warsaw Summit przyciąga rokrocznie ponad 500 uczestników - profesjonalistów od dużych danych.

Z kodem „springitup” specjalna zniżka :) (tylko do końca marca)

Osobiście też się wybieram, dlatego do zobaczenia w kwietniu w Warszawie lub online! :)

Big Data Technology Warsaw Summit 2022

Wed, 09 Mar 2022 00:00:00 +0000

Z wielką przyjemnością zapraszamy na trzy darmowe webinary organizowane przed Big Data Technology Warsaw Summit 2022 :)

Prezentacje zapowiadają się bardzo ciekawie, w tym takie tematy jak:

Apache Kafka and Flink: Stateful Streaming Data Pipelines made easy with SQL by Francesco Tisiot, Developer Advocate, Aiven
Flink’s Table & DataStream API: A Perfect Symbiosis by Timo Walther Staff Engineer, Ververica
Tweet-Topic Classification: The Real-Life Perspective by Mateusz Fedoryszak ML Engineer, Twitter
No-code ML predictions in real-time with ksqlDB and MLeap by Mariusz Strzelecki Senior Machine Learning Engineer, GetInData

Webinaria odbędą się 15 i 22 marca oraz 8 kwietnia. Podczas każdego spotkania będzie można wziąć udział w naszym konkursie i wygrać zaproszenie na Big Data Technology Summit 2022 oraz dostęp do nagrań z ostatniej edycji!

Zapraszam do rejestracji :)

Historia powstaja jednego z najważniejszych projektów ostatnich lat, czyli Kubernetes!

Wed, 02 Feb 2022 00:00:00 +0000

Kubernetes to jeden z ważniejszych projektów ostatnich czasów. Jest istotny zarówno dla osób pracujących w on premise jak i w chmurze publicznej. Dla wielu jest to wręcz idealne narzędzie do stworzenia tak zwanej “chmury prywatnej”. Używany zarówno w rozwoju własnych aplikacji jak i coraz częściej jest podstawą dla rozwiązań Big Data!. W wielu firmach, tam gdzie tylko się da, kontenery uruchamiane z pomocą Kubernetes zastępują wirtualizację.

Jeśli interesuje Was jak doszło do powstania tego projektu, poniżej dwuczęściowy film dokumentacyjny, gorąco polecam :)

Część 1:

Część 2:

Czego uczyć się w 2022 roku by zostać inżynierem danych

Mon, 17 Jan 2022 00:00:00 +0000

Rynek analityki danych, szczególnie tej “wielkogabarytowej” jest jeszcze dość młodą działką w IT. Jest to też coraz bardziej strategiczny rynek dla wielu firm inwestujących w niego coraz większe pieniądze. Skutkiem tego rynek coraz szybciej się zmienia, powstaje coraz więcej narzędzi mających zaspokoić rosnące potrzeby firm oraz wzrasta także zapotrzebowanie na specjalistów potrafiących z nich korzystać, co w IT wcale nie jest takie proste, o czym wie każdy kto ma kontakt z tą branżą. Pojawia się zatem pytanie, co należy umieć by zacząć swoją pracę z analityką danych. W artykule skupimy się na jednym z częściej poszukiwanych specjalistów, czyli inżynierem danych (data engineer).

Naucz się programować

Na pierwszym miejscu, dość nietypowo w stosunku do większości poradników w internecie, wskażę umiejętność programowania. Oczywiście od lat mówi się, że programista zostanie zastąpiony przez wyspecjalizowane algorytmy które będą generować same kod na życzenie biznesu, ale nadal umiejętność programowania, jest jedną z podstawowych które musi zdobyć inżynier danych. Najbardziej podstawowym i powszechnym językiem “programowania” jest oczywiście SQL. W świecie analizy danych jego rola jest dużo większa niż komuś z innego obszaru IT mogłoby się wydawać, gdyż poza standardowym i popularnym zastosowaniem do komunikacji z bazami danych, także tymi NoSQL powszechnie używanymi tutaj, jest on także używany to pracy z takimi narzędziami jak np. Hive, Presto, Trino, Spark, Flink czy Kafka (ksqlDB).

Dodatkowo warto znać przynajmniej jeden z języków programowania ogólnego zastosowania. Wśród osób zajmujących się data science lub uczeniem maszynowym króluje oczywiście język Python jeśli chodzi o popularność, jednak inżynierowie danych bardzo często sięgają także po język Scala oraz Java. Oczywiście można spotkać oferty wymagające znajomości innych języków jak choćby Go, R, C++, Kotlin, Groovy, C# czy JavaScript ale zdecydowanie najpopularniejszymi są Python, Scala oraz Java.

Niestety poznanie składni języka to zdecydowanie za mało. By zostać programistą należy jeszcze mieć wiedzę o takich aspektach wytwarzania kodu jak algorytmy i struktury danych, czysty kod, wzorce projektowe czy testowanie kodu. Niezwykle przydatna będzie też znajomość jakiegoś środowiska programistycznego (np. IntelliJ IDEA, PyCharm, Visual Studio Code), notebooków data science (np. Jupyter, Zeppelin) czy umiejętność korzystania z systemu kontroli wersji (np. Git).

Poznaj swoje narzędzia

Inżynierowie danych w swojej pracy korzystają z wielu narzędzi ułatwiających pracę z danymi, dlatego ich poznanie jest bardzo ważne i cenne dla pracodawców. Patrząc na rozwój tych narzędzi, można zauważyć pewne ery rozkwitania i popularyzacji różnych narzędzi. Wszystko zaczęło się od rozwiązania jakim jest Apache Hadoop który do dzisiaj jest podstawą większości platform Big Data (mam tutaj na myśli komponenty HDFS i YARN). Drugim narzędziem które zdobyło rynek jest Apache Spark, jest to najprawdopodobniej najczęściej wymieniana technologia w ofertach dla inżynierów Big Data. Po erze przetwarzania wsadowego (batch) przyszła kolej na rozwój narzędzi przetwarzania strumieniowego i tak na dobre zagościła w ofertach pracy Apache Kafka a niedługo później coraz częściej firmy zaczęły poszukiwać inżynierów znających także Apache Flink. W ostatnim czasie do narzędzi wiodących prym w ofertach pracy dołączył także Apache Airflow. Znając te 5 narzędzi, będziemy mogli złożyć CV na większość ofert inżyniera danych.

Chcąc swobodnie poruszać się w obszarze danych, należy dobrze poznać także narzędzia w których te dane będą się znajdować. Oczywiście podstawowym miejscem składowania naszych dużych zbiorów danych będzie w większości przypadkach Data Lake (np. HDFS, Amazon S3, Google Cloud Storage, Azure Data Lake). Coraz częściej rozszerza się możliwości jezior danych wykorzystując rozwiązania takie jak Apache Iceberg, Delta Lake lub Apache Hudi. Praktycznie każda większa firma będzie korzystać także z hurtowni danych, dlatego znajomość tego typu narzędzi może się okazać dużym plusem dla naszego przyszłego pracodawcy. Skoro najpopularniejszym językiem w IT jest od dawna język SQL, nie sposób zapomnieć o bazach danych, zarówno tych klasycznych, relacyjnych jak również rozwiązań NoSQL jak Cassandra, HBase, Redis czy MongoDB.

Chmura obliczeniowa to przyszłość

Adopcja chmury w Polsce stawia nas niestety w końcówce wszelkich europejskich rankingów, jednak większość specjalistów uważa, że dogonienie zagranicznych rynków to tylko kwestia czasu, zaś znajomość chmury publicznej to obecnie jedna z najczęściej poszukiwanych umiejętności na rynku pracy. Oczywiście trzeba się liczyć z tym, że pracując dla polskiej firmy, nasz kontakt z chmurą będzie jeszcze dość ograniczony, jednak tempo rozwoju rozwiązań chmurowych i mnogość dostępnych tam narzędzi sprawia, że im wcześniej poznamy możliwości chmury publicznej tym łatwiej nam będzie znaleźć wymarzoną posadę w przyszłości.

Trzeba tutaj zaznaczyć, że w chmurze spotkamy zarówno rozwiązania dobrze nam znane z platform onpremise jak Spark, Kafka czy Airflow które będą przez dostawców dostosowane do pracy w środowisku chmury publicznej, oraz także spotkamy tutaj konkurencyjne natywne narzędzia jak np. zamiast HDFS będziemy budować nasze jezioro danych w oparciu o Amazon S3, Google Cloud Storage lub Azure Data Lake zaś zamiast Kafki będziemy mogli wybrać Amazon Kinesis lub Google Pub/Sub. Należy tutaj wspomnieć także, że oprócz rozwiązań od czołowych dostawców takich jak Amazon Web Services, Google Cloud Platform lub Microsoft Azure coraz częściej firmy sięgają po rozwiązania firm trzecich dostępnych w chmurze publicznej jak np. Snowflake lub Databricks Unified Data Analytics Platform (obydwa narzędzia dostępne są w chmurze AWS, GCP oraz Azure).

Konteneryzacja to już codzienność

Przez długi czas konteneryzacja była kojarzona z dostarczaniem aplikacji, np. mikroserwisów. Od jakiegoś czasu jednak dla wielu firm kontenery to podstawa działania, zaś Docker i Kubernetes stały się bardziej strategicznym środowiskiem niż maszyny wirtualne. Coraz częściej słyszy się, że firmy migrują swoje platformy Big Data w części lub całości na Kubernetes. Oczywiście dzieje się to dzięki temu, że twórcy popularnych rozwiazań Big Data jak Spark, Flink lub Kafka Streams wspierają takie wdrażanie. Także duzi dostawcy platform Big Data jak AWS lub Cloudera umożliwili pracę ze swoimi platformami Big Data zarówno w wersji opartej o klasyczne wdrożenie na maszyny wirtualne / fizyczne jak i w oparciu o Kubernetes.

Podsumowanie

Powyżej, w czterech akapitach, wymieniłem najważniejsze (oczywiście moim zdaniem) obszary w których powinien rozwijać się inżynier chcący swobodnie pracować z danymi. Oczywiście w ofertach pracy dla inżynierów danych będą pojawiać się także inne wymagania tutaj pominięte, jednak w mojej ocenie, obserwując rynek zarówno od strony ofert pracy jak i kierunku w jakie idą firmy w Polsce i na świecie, te cztery obszary są kluczowe.

Raport AI@Enterprise 2021!

Mon, 07 Jun 2021 00:00:00 +0000

Poszukujesz informacji na temat zastosowania sztucznej inteligencji w biznesie?

Pobierz najnowszy Raport AI@Enterprise 2021! Gorąco polecamy!

Dzięki lekturze Raportu:

Zobaczysz na konkretnych przykładach, z jakimi wyzwaniami wiąże się wdrażanie rozwiązań wykorzystujących sztuczną inteligencję.
Poznasz doświadczenia ekspertów, którzy mają już za sobą realizację projektów dotyczących wykorzystania technologii AI w organizacjach z różnych branż.
Dowiesz się jak w praktyce wyglądają korzyści z wdrożeń AI i z jakimi barierami w ich realizacji można się spotkać.

Link do pobrania tutaj: https://aisummit.today/aie-raport2021/

Nie przegap tej publikacji

AI@Enterprise Summit 2021

Fri, 04 Jun 2021 00:00:00 +0000

Jak jeszcze lepiej wykorzystać możliwości sztucznej inteligencji w biznesie?

Dowiedz się podczas AI@Enterprise Summit 2021 – 9-10 czerwca, online!

Sztuczna inteligencja coraz mocniej wkracza do świata biznesu, zmieniając sposób pracy firm i umożliwiając powstanie całkowicie nowych usług i modeli biznesowych. Jest to możliwe dzięki kilku czynnikom: rozwoju technologii Big Data, rosnącej popularności rozwiązań chmurowych, automatyzacji oraz przyspieszającej transformacji cyfrowej.

Czas zacząć czerpać korzyści z zastosowania sztucznej inteligencji w praktyce!

Zapraszamy do udziału w konferencji AI@Enterprise Summit 2021!

Będzie to spotkanie zarówno dla specjalistów od danych, jak i programistów, ekspertów machine learning, inżynierów DevOps, managerów, którzy chcą wdrażać rozwiązania AI w swoich firmach.

Dlaczego warto wziąć udział w AI @ Enterprise Summit 2021?

spotykasz się z ponad 50 ekspertami AI z całego świata - wizjonerami i ekspertami, którzy pracują w największych światowych firmach!
wybierzesz dla siebie najciekawsze tematy z 3 praktycznych ścieżek, które obejmują najważniejsze, aktualne aspekty sztucznej inteligencji!
Podczas dyskusji roundtable wymienisz się doświadczeniami z innymi uczestnikami wydarzenia
Rozwiniesz swoje umiejętności podczas warsztatów - czekają na Ciebie 4 warsztaty techniczne i praktyczne!

Swoimi doświadczeniami podzielą się znakomici praktycy sztucznej inteligencji!

Wystąpią m.in.:

Building End-to-End Machine Learning Workflows with Kubernetes, Kubeflow Pipelines, and BERT - Antje Barth, Amazon Web Services (AWS)
10 biggest mistakes when creating AI products - Jaekob Chenina, Scuba Analytics
Better Understand Your Documents with AI - Elliott (Feng) Ning, Google
Finding duplicate images made easy in python with imagededup - Tanuj Jain, Axel Springer AG
Scalable AI deployment on the edge - Maurits Kaptein, Tilburg University, Scailable
Text Summarization with Transformer Models – Exploring New Frontiers in NLP - Nataliia Kees, qdive GmbH
AI methods for predictive maintenance in production processes - Prof. Dr. Thomas Kopinski, University of South Westphalia
Implementing a ML data product for lead management with focus of the insurance industry - Nina Meinel, Syncier Analytics
Production-grade ML Pipelines - From Data To Metadata - Jörg Schad, ArangoDB
Bigdata, ML & AI Fundamentals for Managers – A pragmatic view beyond hype! - Samuel Rostam, New York Institute of Technology, Arcitura Education

Jeszcze możecie dokonać bezpłatnej rejestracji, ale szybko kończą się bezpłatne miejsca!

Szczegóły dotyczące udziału znajdziecie na stronie

Jesteśmy patronem wydarzenia dlatego spotkamy się na AI@E Summit 2021! Do zobaczenia!

Big Data Technology Warsaw Summit 2021

Mon, 25 Jan 2021 00:00:00 +0000

Już niebawem dla wszystkich specjalistów Big Data, Data Science oraz inżynierii danych najlepsza okazja w roku - duża międzynarodowa konferencja Big Data Technology Warsaw Summit 2021 odbędzie się 25-26 lutego 2021, w formule online!

Nie możesz tego przegapić!

Prelegenci Big Data Technology Warsaw Summit to wybitni fachowcy – inżynierowie, architekci, deweloperzy z Polski oraz zagranicy.

Swoimi doświadczeniami podzielą się m.in.:

Foundations of Data Teams - Jesse Anderson, Data Engineer, Creative Engineer and Managing Director, Big Data Institute
Make it personal: reinforcement learning for mere mortals - Konrad Banachewicz, Lead Data Scientist, eBay Classifieds Group
Lessons from building large-scale, real-time machine learning systems - Boxun Zhang, Data Science Lead, Unity
How to build a state-of-the-art weather forecasting AI service - Axel Karlsson, AI Research Engineer, Peltarion
Data Quality with 100+ PB: Solved Challenge at Criteo - Alexandre Terrien, Data Engineer, Criteo; Lucie Bailly, Lead Data Engineer, Criteo
Telecom systems Degradation Prediction using ML - Shivendra Upadhyay, Senior Data Scientist, Ericsson R&D
MLOps journey in H&M - Keven(Qi) Wang, Competence lead , Machine learning engineer, H&M

Konferencja jest praktyczna i technologiczna – towarzyszą jej dwa dni warsztatów do wyboru:

Real-Time stream processing - Grzegorz Kołakowski oraz Adrian Bednarz z GetInData
Big Data on Kubernetes - Maciej Bryński z DXC Technology
Foundations of data engineering with Google Cloud - Mateusz Pytel z GetInData

Dołącz do uczestników konferencji i skorzystaj z promocji przy rejestracji do 5 lutego!

Z kodem „bigdatapassion” otrzymasz 10% rabatu na udział w konferencji!

Wszystkie informacje znajdziesz na stronie

Politechnika Warszawska i nowoczesne technologie w AWS!

Thu, 17 Dec 2020 00:00:00 +0000

Na kanale YouTube AWS Polska pojawiła się moja rozmowa z Tomkiem Stachlewskim o tym jak wykorzystujemy nowoczestne technologie chmurowe w nauczaniu Big Data na Politechnice Warszawskiej.

Zachęcam do obejrzenia :)

Od Data Lake do AI czyli jak zdobyć wierzchołek góry lodowej z pomocą chmury publicznej

Wed, 30 Sep 2020 00:00:00 +0000

Poniżej nagranie mojego wystąpienia na konferencji AI & NLP Workshop Day która dobyła się w dniach 26 - 27 października 2020 roku w Warszawie.

Skrót wystąpienia można znaleść tutaj.

Pierwsza część to wstęp teoretyczny, druga to praktyczne demo.

Serdecznie zapraszam do obejrzenia :)

Od Data Lake do AI czyli jak zdobyć wierzchołek góry lodowej z pomocą chmury publicznej

Thu, 24 Sep 2020 00:00:00 +0000

W dniach 26 - 27 października 2020 roku będę miał przyjemność poprowadzić prezentację “Od Data Lake do AI czyli jak zdobyć wierzchołek góry lodowej z pomocą chmury publicznej” w ramach wydarzenia AI & NLP Workshop Day.

Data Lake i Artificial Intelligence to dzisiaj bardzo popularne slogany marketingowe powtarzane przez wiele firm zaczynających swoją przygodę z analizą danych. Tak naprawdę obydwa terminy znane są od dawna, jednak z racji coraz większej dostępności narzędzi i rosnącej mocy obliczeniowej technologie kojarzone do tej pory z firmami takimi jak Google, Amazon, Facebook i Apple (GAFA / Wielka czwórka) trafiają do wielu mniejszych organizacji. Jednak co się kryje za tymi frazesami? Ile pracy trzeba włożyć by od pierwszych bajtów danych otrzymać wartościowe rekomendacje naszych modeli predykcyjnych? Zbudować to u siebie czy skorzystać z narzędzi dostępnych na wyciągnięcie ręki w chmurze publicznej? Z jakich narzędzi skorzystać w środowisku on premise a w jakich w chmurze. Jakie są zalety jednych i drugich. Jak to połączyć z naszymi obecnymi rozwiązaniami, w tym Business Intelligence? Ile to będzie nas kosztować?

Na te wszystkie pytania będę chciał odpowiedzieć w prezentacji poświęconej drodze jaką musi przejść każda firma chcąca wdrożyć rozwiązania analizy danych. Prezentacja jest adresowana zarówno do osób technicznych, w szczególności projektantów i architektów jak i osób podchodzących do tematu od strony biznesowej.

Słowa kluczowe: Data Lake, Artificial Intelligence, Data Center, AWS, Azure, Google Cloud, Databricks, Snowflake, Cloudera

ALK - Data Science i Big Data w Zarządzaniu 2020

Sat, 29 Aug 2020 00:00:00 +0000

Miło mi poinformować, że po raz kolejny mam przyjemność współtworzyć kadrę prowadzącą zajęcia na studiach Data Science i Big Data w zarządzaniu w Akademii Leona Koźmińskiego.

Prowadzę przedmiot poświęcony budowaniu własnych środowisk Big Data i Data Science, zarówno on premise jak i w chmurze. Więcej szczegółów: https://www.kozminski.edu.pl/pl/oferta-edukacyjna/studiapodyplomowe/kierunki/big-data/program/

AI & NLP WORKSHOP DAY 2020

Wed, 19 Aug 2020 00:00:00 +0000

Jest nam niezmiernie miło poinformować, że właśnie ruszyła sprzedaż biletów na tegoroczną edycję AI & NLP Day! Jest to już trzecia edycja konferencji poświęconej sztucznej inteligencji oraz przetwarzaniu języka naturalnego.

Podczas konferencji będziesz miał możliwość porozmawiania z ekspertami, naukowcami, a także zwycięzcami konkursu PolEval.

Będziesz mógł wybrać warsztaty pośród trzech ścieżek: uczenie maszynowe/sztuczna inteligencja, Big Data, przetwarzanie języka naturalnego oraz posłuchać prelekcji uczestników konkursu PolEval.

Dzień warsztatów to czas wymiany pomysłów oraz czas rozmów biznesowych pomiędzy uczestnikami ze świata akademickiego oraz biznesu.

Jakich ekspertów możesz się spodziewać w trakcie tego wydarzenia?

Są to ludzie ze świata nauki i biznesu, Prelegenci i Trenerzy, Eksperci posiadający szeroką wiedzę.

Specjalnie dla czytelników przygotowaliśmy zniżkę na zakup biletu -10% od ceny Early Bird!

Aktualne ceny w przedsprzedaży obowiązują jedynie do 31 sierpnia, więc naprawdę warto skorzystać z promocji jak najszybciej!

KOD RABATOWY: 148s322k1x

Więcej szczegółów na stronie konferencji.

Linux Mint 20 / Ubuntu 20.04 - instalacja przydatnych narzędzi do pracy

Mon, 20 Jul 2020 21:28:14 +0100

Do pracy, zwłaszcza tej komfortowej, potrzebujemy odpowiedniego oprogramowania które nam w tym pomaga. Od kilkunastu miesięcy moją dystrybucją numer jeden w świecie Linuxa stał się Mint, dlatego poniżej lista części moich narzędzi z których bardzo często korzystam wraz z instruckją instalacji.

Wersje oprogramowania

Linux Mint bazuje na dystrybucji Ubuntu która to bazuje na dystrybucji Debian, dlatego podczas instalacji pakietów będziemy instalować odpowiadające wersje dla Ubuntu lub Debian.

Linux Mint 20 (Ulyana) bazuje na Ubuntu 20.04 LTS (Focal Fossa) który bazuje na Debian 11 (bullseye).

Więcej o wersjach można znaleźć na stronach:

Dlaczego Mint? Przede wszystkich preferuje dystrybucje oparte o Debian. Niestety repozytoria Debiana są nastawione na stabilność przez co wersje oprogramowania są starsze niż w innych dystrybucjach, zaś po kilku latach korzystania z Debiana w wersji testowej stwierdziłem że czas na stabilizację :D Początkowo postawiłem na dystrybucję Ubuntu, ale nieprzepadam za Unity czyli domyślnym managerem pulpitu w obecnych wersjach Ubuntu, stąd linux Mint wydał się najrozsądniejszą opcją :). Używam pulpitu Cinnamon oraz KDE.

Podstawowe pakiety Linux

apt install -y \
    alacarte \
    bmon \
    byobu \
    chromium-browser \
    clusterssh \
    filezilla \
    gedit \
    git \
    gimp \
    gource \
    htop \
    iptraf \
    keepassx \
    konsole \
    mc \
    meld \
    multitail \
    mkvmerge \
    mkvtoolnix \
    mkvtoolnix-gui \
    ncdu \
    obs-studio \
    openssh-server \
    openvpn \
    python3-pip \
    pavucontrol \
    ssh \
    sshfs \
    tree \
    vim \
    vim-addon-manager \
    virtualenv \
    webcamoid \
    wget

GIT

W przypadku git’a warto od razu dodać podstawową konfigurację:

git config --global user.name "Imię Nazwisko"
git config --global user.email "naszEmail@host.com"

Ansible

apt update
apt install software-properties-common
apt-add-repository --yes --update ppa:ansible/ansible
apt install ansible

ansible --version

https://docs.ansible.com/ansible/latest/installation_guide/intro_installation.html#installing-ansible-on-ubuntu

Docker

apt remove docker docker-engine docker.io containerd runc

apt update

apt install \
    apt-transport-https \
    ca-certificates \
    curl \
    gnupg-agent \
    software-properties-common

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -

sudo apt-key fingerprint 0EBFCD88

# cat /etc/os-release
# or
# lsb_release -cs

sudo add-apt-repository \
   "deb [arch=amd64] https://download.docker.com/linux/ubuntu \
   focal \
   stable"

apt update
apt install docker-ce docker-ce-cli containerd.io

docker --version
docker run hello-world

sudo curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
chmod +x /usr/local/bin/docker-compose
# ln -s /usr/local/bin/docker-compose /usr/bin/docker-compose

docker-compose --version

https://docs.docker.com/engine/install/ubuntu/ https://docs.docker.com/compose/install/

Virtualbox

echo "deb [arch=amd64] http://download.virtualbox.org/virtualbox/debian focal contrib" | sudo tee /etc/apt/sources.list.d/virtualbox.list
wget -q http://download.virtualbox.org/virtualbox/debian/oracle_vbox.asc -O- | sudo apt-key add -
wget -q https://www.virtualbox.org/download/oracle_vbox_2016.asc -O- | sudo apt-key add -
wget -q https://www.virtualbox.org/download/oracle_vbox.asc -O- | sudo apt-key add -

apt update
sudo apt install -y virtualbox-6.1

Latex

apt install -y texlive

apt install -y texlive-binaries
apt install -y texlive-fonts-recommended
apt install -y texlive-generic-recommended
apt install -y texlive-latex-base
apt install -y texlive-latex-extra
apt install -y texlive-latex-recommended
apt install -y texlive-pictures

apt install -y texlive-lang-polish

Google Chrome

echo "deb [arch=amd64] http://dl.google.com/linux/chrome/deb/ stable main" | sudo tee /etc/apt/sources.list.d/google-chrome.list
wget -q -O - https://dl.google.com/linux/linux_signing_key.pub | sudo apt-key add -

apt update
apt install -y google-chrome-stable

Spotify

curl -sS https://download.spotify.com/debian/pubkey_0D811D58.gpg | sudo apt-key add -
# echo "deb [arch=amd64] http://repository.spotify.com stable non-free" > /etc/apt/sources.list.d/spotify.list
apt install spotify-client

Slack

# download from https://slack.com/intl/en-pl/downloads/linux
sudo apt install ./slack-desktop-4.10.3-amd64.deb

Zoom

# download from https://zoom.us/download?os=linux
sudo apt install ./zoom_amd64.deb

Signal

wget -O- https://updates.signal.org/desktop/apt/keys.asc | sudo apt-key add -
echo "deb [arch=amd64] https://updates.signal.org/desktop/apt xenial main" |  sudo tee -a /etc/apt/sources.list.d/signal-focal.list
sudo apt update && sudo apt install signal-desktop

Dropbox

apt install -y dropbox

Next Cloud

apt install -y nextcloud-client

Mega.nz

TODO

Syncthing

From: https://apt.syncthing.net/

curl -s https://syncthing.net/release-key.txt | sudo apt-key add -
echo "deb https://apt.syncthing.net/ syncthing stable" | sudo tee /etc/apt/sources.list.d/syncthing.list
sudo apt update
sudo apt install syncthing

DBeaver

wget -O - https://dbeaver.io/debs/dbeaver.gpg.key | sudo apt-key add -
echo "deb https://dbeaver.io/debs/dbeaver-ce /" | sudo tee /etc/apt/sources.list.d/dbeaver.list
apt update && sudo apt install dbeaver-ce

Aktualizacja systemu

Poniżej polecenie aktualizacji całego systemu:

apt update && apt upgrade && apt dist-upgrade && apt autoremove && apt clean && apt autoclean && updatedb

Przydatne ustawienia w systemie

vim /etc/sysctl.conf
echo "vm.swappiness = 5" >> /etc/sysctl.conf
reboot
cat /proc/sys/vm/swappiness

Idea zarządzania zadaniami w Apache Airflow

Sun, 05 Apr 2020 00:00:00 +0000

Apache Airflow to obecnie jedno z najpopularniejszych narzędzi służących do zdecentralizowania cyklicznie uruchamianych zadań w postaci workflow/pipeline. Za pomocą kodu definiujemy przepływy pracy i planujemy ich wykonanie. Dostępny lekki interfejs API jak i interfejs graficzny (WebUI) co daje możliwość wizualizacji nawet dość skomplikowanych diagramów i monitorowania ich działania co przekłada się na łatwiejsze rozwiązywanie problemów. Mamy do dyspozycji dziennik, historia zadań i szablony jinja co znacząco rozszerza możliwości kodu. Mamy jedno miejsce, gdzie przechowujemy nasz kod i jego wyniki - rejestr działania naszych zadań - znacząco to ułatwia, gdyż samo opisanie tych przepływów jako kod daje większą swobodę w utrzymywaniu, wersjonowaniu i współdzieleniu naszych zadań.

W środowiskach produkcyjnych potrafi uruchomić 3500 sparkowych jobów dziennie na 50 klastrach Apache Hadoop źródło - duża skala, robi wrażenie.

Apache Airflow udowodnił, że można budować przepływy pracy bez skomplikowanych plików konfiguracyjnych lub szczegółowych definicji DAG.

Jak powstał Airflow?

Projekt Airflow wystartował w październiku 2014 roku dzięki Maxime Beauchemin w Airbnb. Od początku było to oprogramowanie typu open source i od czerwca 2015 roku oficjalnie hostowane na GitHub na profilu Airbnb. Projekt dołączył do programu Inkubatora Apache Software Foundation. W marcu 2016 r. Fundacja ogłosiła Apache Airflow jako projekt “najwyższego poziomu” (ang. first level) w styczniu 2019 r.

Warto wspomnieć o sponsorach tego projektu, m. in.


Comcast	Pineapple Fund	Microsoft
Google	LeaseWeb	Tencent
Amazon Web Services	Facebook	Cloudera

Pozostali to: ARM, Bloomberg, Handshake, Huawei, IBM, Indeed, Union Investment, Workday jak i anonimowi darczyńcy.

Zalety

Główny język to Python

Python jest użyty do tworzenia kodu przepływu pracy w tym formatów daty i godziny do planowania zadań i pętli do dynamicznego generowania zadań.

Interfejs graficzny

Monitoruje, planuje i zarządza przepływami pracy za pomocą interfejsu webowego, gdzie mamy dostęp do w statusu ukończonych i bieżących zadań wraz z wglądem w ich logi.

Duża liczba zintegrowanych usług

Dzięki plug-and-play mamy ułatwione zadanie, aby móc się połączyć z pewnymi usługami udostępnionymi przez np. dostawców chmurowych AWS, GCP czy Azure.

Łatwość

Wystarcza wiedza o języku Python, aby móc już transferować dane, zarządzać infrastrukturą czy nawet budować modele machine learning.

Projekt Open Source

Airflow ma wielu aktywnych użytkowników, którzy chętnie dzielą się swoimi doświadczeniami. Zalet OS jest wiele, więc chętnie z tego korzystamy :).

Architektura

Ogólna architektura przedstawianego rozwiązania składa się z poniższych elementów:


web server	master repo	scheduler	code repo	metadata database	workers

      [ PostgreSQL ]  [ MariaDB ] 
      ____/_____________/_ _ _ _ _
     |
     |    A I R F L O W
     |          
  [ webserver ]  [ executor ]

    [ repo ]     scheduler + worker

 code + master

Wybrane elementy systemu i pojęcia

DAG Directed Acyclic Graph

Najłatwiej tłumaczyć to sobie jako zadania a grupa takich zadań wykonuje już jakąś pracę. Przykładem może być zadanie Sparkowe, ETL, ML, CI, etc.

Jinja szablony

Wbudowane szablony pozwalają na używanie wielu zmiennych czy makr (np. szczegóły zadania, znacznik czasu wykonania) podczas wykonywania zadania. Ogólnie pobierają informację o środowisku.

API zaimplementowane w Pythonie

Interfejs API może zostać wykorzystany do m. in. bardziej jawnej kontroli procesów.

Czas i Planowanie

W Airflow nie ma możliwości uruchomienia jakiegokolwiek zadania DAG bez wskazania daty wykonania. Podobnie DAG nie może być uruchomiony kilkukrotnie w tym samym czasie tj. dla tej samej daty wykonania. Jeśli istnieje konieczność uruchomienia wielu instancji zadania to (bez kreatywności - potrzeba matką wynalazków;)) nie ma takiej możliwości. Ciekawsze jest to, że data wykonania execution_date to nie jest to samo co data rozpoczęcia zadania - należy o tym pamiętać. Data wykonania to miejsce w czasie od którego może zostać uruchomione zadanie DAG.

Na poniższym wykresie gwiazdki oznaczają planowany czas wykonania zadania (interwał to codziennie o 5:05), kratka wskazuje zdefiniowaną datę wykonania, dolar oznacza kiedy uruchomiliśmy DAG a duży iks kiedy zadanie się jeszcze nie mogło wykonać. (Tak, lubię ASCII art).

     data                  (harmonogram)
 uruchomienia           [schedule_interval]
 zadania  DAG                '5 5 * * '
      |                           |
_ _ _ | _ ________________________|_____________ _ _ 
    | |   |     |     |     |     |     |     |
 - -X-$---X---#-*-----*-----*-----*-----*-----*- - - >
              |                                 (oś czasu)
         '{{ ds }}'
      [execution_date]
      (data wykonania)

W przypadku, gdy nie chcemy planowania wyłączamy możliwość za pomocą schedule_interval=None. Jeśli mamy cykliczność naszego zadania DAG to możemy użyć adnotacji podobnie jak w linuksowym cronie - przykład dla oby dwóch form w tabelce.

opisowo	jak w CRONie	interwal
None	brak zapisu	Brak powtarzalności
@once	brak zapisu	Uruchamiamy tylko raz
@hourly	0 * * * *	Godzina
@daily	0 0 * * *	Dzień
@weekly	0 0 * *	Tydzień
@monthly	0 0 1 * *	Miesiąc
@yearly	0 0 1 1 *	Rok

Do dyspozycji posiadamy jeszcze określenie punktu początkowego start_date i końcowego end_date na osi czasu. Data początkowa niekoniecznie musi być wykonana, gdy pierwszy przebieg DAG zostanie wykonany, ponieważ

Domyślne zmienne

Zmienne określające czas w większości się duplikują a wszystko za sprawą postfiksa _nodash, który wprowadza inny zapis. Dla przykładu zapis {{ ds }} i {{ ds_nodash }} wskazuje na tą samą zmienną i wartość z tą różnicą, że wartość ma dwa różne zapisy. Przykłady w tabelce.

ds	YYYY-MM-DD
Przykład	2020-03-03

ds_nodash	YYYYMMDD
Przykład	20200303

Pod tabelką opisałem ważniejsze cechy.

Zmienne	Opis
{{ ds }} {{ ds_nodash }}	Data wykonania
{{ prev_ds }} {{ prev_ds_nodash }}	Jeśli istnieje - wcześniejsza data wykonania
{{ next_ds }} {{ next_ds_nodash }}	Jeśli istnieje to kolejny zapis czasu kiedy jest planowane uruchomienie
{{ yesterday_ds }} {{ yesterday_ds_nodash }}	Dzień wcześniej
{{ tomorrow_ds }} {{ tomorrow_ds_nodash }}	Kolejny dzień
{{ ts }} {{ ts_nodash }}	Dokładniejszy czas w formacie ISO

Dla prev_ds / prev_ds_nodash wcześniejszą datę możemy otrzymać, jeśli był wprowadzony interwal w schedule_interval np. @daily - tu zapis jaki powinien się pojawić to 2020-03-02 / 20200302. Tak samo to wygląda dla przyszłych dat a więc dla next_ds / next_ds_nodash. Należy zauważyć: jeżeli Airflow nie jest w stanie wyświetlić właściwych wartości to przekaże None.

Format ISO:

dla ts: 2020-03-03T00:00:00+01:00 - wzorowy zapis,
dla ts_nodash: 20200303T0000000100 - usunięte wszystkie znaki, które nie są alfanumeryczne i brak informacji o strefie czasowej,
dla ts_nodash_with_tz: 20200303T0000000100 - usunięte wszystkie znaki, które nie są alfanumeryczne.

Operatory

Każde zadanie jest zbudowane za pomocą operatorów - można wykorzystać już istniejące (domyślne wbudowane, zobacz https://github.com/apache/airflow/tree/master/airflow/operators) lub napisać własne. Operatory określają co zostanie wykonane przy uruchomieniu zadania. Podzielić je można na kilka grup:


	BashOperator	Dingding Operators	Google Cloud Operators
	Papermill	PythonOperator	Cross-DAG Dependencies

Przykładem może być: https://airflow.apache.org/docs/stable/_modules/airflow/example_dags/example_bash_operator.html. Operator można połączyć z szablonami co znacząco rozszerza jego produktywność. Nie bez znaczenia jest spacja na końcu polecenia, bez niej Python nie może odczytać szablonu.

Błędna składnia

passion0x00 = BashOperator(
  task_id=`bigdata`,
  bash_command="bigdatapassion.sh",
  dag=dag)

Właściwa składnia (z odstępem na końcu polecenia)

passion0x00 = BashOperator(
  task_id=`bigdata`,
  bash_command="bigdatapassion.sh ",
  dag=dag)

Bardzo szybki start

Nie musimy instalować, możemy skorzystać z już istniejących rozwiązań SaaS dostępnych w chmurze - np. Google Cloud Platform (GCP) (https://cloud.google.com/composer/docs/how-to/accessing/airflow-web-interface) lub lokalnie uruchomić obraz Docker’a - https://github.com/puckel/docker-airflow.

Instalacja

Zalecanym sposobem wdrożenia środowiska Airflow jest instalacja za pomocą menedżera pakietów pip.

pip install apache-airflow

Powyższe polecenie zainstaluje minimalny zestaw pakietów potrzebny do uruchomienia środowiska. Fakultatywnie dla naszego środowiska można domieszać takie składniki jak integracja z bazami danych (np. PostgreSQL, MariaDB, Microsoft SQL Server), integracje z platformami autoryzacji (np. LDAP, Google Auth, GitHub Auth), czy z środowiskami chmurowymi (np. Amazon Web Services, Microsoft Azure, Google Cloud Platform). Przykład dla zdalnego wykonywania zadań za pomocą połączenia SSH:

pip install 'apache-airflow[ssh]'

Do dyspozycji mam ponad 30 dodatkowych pakietów umożliwiające nam rozwinięcie funkcjonalności naszej instancji Airflow. Należy zwrócić uwagę, że dla środowisk produkcyjnych należy posłużyć się zewnętrzną bazą danych (np. PostgreSQL lub MariaDB/MySQL) a dla testowych pozostać można przy domyślnej SQLite.

Po instalacji wymagana jest inicjalizacja bazy danych - nie ma znaczenia czy to dla SQLite czy innych zewnętrznych.

airflow initdb

Połączenie z bazami danych realizowane jest za pomocą biblioteki SqlAlchemy (udostępnia funkcjonalność SQL bez potrzeby pisania bezpośrednio zapytań do bazy za pomocą tradycyjnego SQLa, wspiera ponad 25 typów połączeń do baz danych), dzięki czemu Airflow jest w stanie korzystać z dowolnej bazy obsługującej backend SqlAlchemy.

Jak ubogacić nasze środowisko?

Z czasem nasze środowisko może się skomplikować, możemy je próbować posprzątać za pomocą:


clear-missing-dags	Okresowo czyści wpisy w tabeli DAG, dla których nie ma już odpowiedniego pliku Python
db-cleanup	Dbanie o porządek w MetaStore czyszcząc DagRun, TaskInstance, Log, XCom, Job DB, wpisy SlaMiss
kill-halted-tasks	Cyklicznie wyszukuje zadania, które są uruchomione a nie ma ich w bazie danych
log-cleanup	Czyścimy dziennik zadań, aby nie utrzymywać jego zbyt dużego rozmiaru
delete-broken-dags	Czyszczenie tabeli ImportErrora, uruchamiamy aby okresowo usuwać pliki DAG i czyścić wpisy w tabeli ImportError dla DAG, których Airflow nie może poprawnie przeanalizować ani zaimportować

Jak nie Airflow to co?

W świecie Big Data jest mnogość alternatyw - zestawienie (poglądowe posortowane alfabetycznie) w tabelce.

Nazwa	Adres / Opis
Adage	https://github.com/yadage/adage
Argo	https://argoproj.github.io/argo/
Aurora	http://aurora.apache.org/
Azkaban	https://azkaban.github.io/
Azure Data Factory	https://docs.microsoft.com/en-us/azure/data-factory
Chronos	https://mesos.github.io/chronos/
Falcon	http://falcon.apache.org/
Kedro	https://github.com/quantumblacklabs/kedro
Luigi	https://github.com/spotify/luigi
NiFi	https://nifi.apache.org/
Oozie	http://oozie.apache.org/
Pinball	https://github.com/pinterest/pinball
Schedoscope	https://github.com/ottogroup/schedoscope
Sparrow Scheduler	https://github.com/radlab/sparrow

AWS re:Invent re:Cap 2019 - AWS User Group PL Meetup - Warsaw

Tue, 21 Jan 2020 00:00:00 +0000

Jak co roku, AWSowy re:Invent dostarczył wielu emocji użytkownikom i sympatykom tej chmury. Jest to największa konferencja organizowana co roku przez AWS gdzie ogłaszane są wszystkie nowości wprowadzane do platformy których co roku jest coraz więcej (aktualnie wypada średnio już ponad 5 dziennie).

Niestety nie każdy może sobie pozwolić na kilkudniowy pobyt na konferencji z dala od domu, dlatego powstała inicjatywa dzielenia się nowościami w platformie z community w wielu krajach na świecie w ramach tak zwanego “AWS re:Invent re:Cap”. Udział w wydarzeniu wzięło 21 europejskich miast, a wśród nich Warszawa.

W Warszawie prezentację poprowadził Alex Casalboni, ja zaś miałem niezwykłą przyjemność wspomóc go i poprowadzić część związaną z nowościami w obszarze Machine Learning, w szczególności w usłudze SageMaker :)

Więcej informacji o wydarzeniu jak i zdjęcia można znaleźć na portalu meetup.

Erasure Coding a Replikacja

Tue, 24 Dec 2019 00:00:00 +0000

Cechy HDFS Erasure Coding

Największą zaletą EC (Erasure Coding) w porównianiu do replikacji to redukcja zajętości miejsca. Przy domyślnej replikacji (3) te same dane w EC zajmują połowę powierzchni dyskowych. Dane są przechowywane w różnych lokalizacjach, gdzie nadal mamy pewność, że w przypadku utraty dysku jesteśmy w stanie odbudować brakujące informacje. Zauważmy, że poziom bezpieczeństwa jest taki sam jak w przypadku replikacji tj. mamy 3 kopie. Wygląda to super i tak w rzeczywistości jest, ale.

Jeden z poważniejszych minusów takiego przechowywania to brak lokalności rekordów (danych). Istotna funkcjonalność HDFS to block locality, którą tracimy wraz z uruchomieniem EC, dlatego że pocięte bloki danych są rozrzucane po DataNodach tzn. lokalnie nie mamy pełnej informacji nad którą możemy pracować. Sama obsługa danych w Erasure Coding to proces wymagający większego zaangażowania zasobów.

Erasure Coding to świetny sposób na archiwizacje zimnych danych lub też tworzenie punktów Disaster Recovery.

  D A N E
  ^
  └─ D'───D'
    / \  / \
   /   \/   \
  d'   d''  d'''
  ^^^^^^^^^^^^^^

Cechy replikacji w HDFS

Podstawową strategią utrzymywania danych w wysokiej dostępności w HDFS jest replikacja. Tworzenie kopii bloków pomaga w ciągłej pracy klastra w przypadku awarii dysku/dysków, węzła/węzłów (np. DN) czy nawet całego zespołu serwerów dla konfiguracji (z wdrożonym podziałem na kilka Rack). Teoretycznie (przy replikacji równej n) w idealnych warunkach (każdy blok danych n-repliki znajduje się w tej samej grupie DataNodów - z podziałem na równe grupy) utrata n-1/n maszyn w klastrze nie powinna przerwać jego działania.

Przechowywanie wielu kopii daje również duży zysk w przypadku zrównoleglenia odczytu (np. hot) danych przez klientów, gdyż każdy klient czyta z wybranych DN (DataNodów).

Replikacja a lokalizacja zasobów

Są dwa podejścia do wykonania replikacji.

W obrębie klastra wykorzystując wbudowane narzędzia lub własne do kopiowania danych pomiędzy instancjami w klastrze i po za nim (np. do AWS S3)
Tworzyć i zarządzać strumieniami dbając o ciągłe przesyłanie informacji do wybranych klastrów lub elementów po za HDFSem (np. ELK Stack)

Dla replikacji w aplikacjach jest kilka narzędzi, które mają wbudowane opisane mechanizmy.

Apache HBase

https://hbase.apache.org/

Przykładem jest baza danych Apache HBase, gdzie algorytm pomaga przenosić wszystkie modyfikacje w cf (column family) na inny klaster. Istnieje również kompleksowe rozwiązanie typu master-master czy master-follower, gdzie każdy zapis jest w czasie rzeczywistym wysyłany na klaster. Idealnym (optymalnym) środowiskiem jest tu połączenie sieciowe o wysokiej przepustowości i niskiej latency (punkty są ‘blisko siebie’). Należy pamiętać, że to nie zastępuje backupu.

Apache Kafka

https://kafka.apache.org/

Innym przykładem jest Apache Kafka, która potrafi przenosić dane do jednego lub wielu klastwów Hadoop.

Apache Flume

https://flume.apache.org/

Świetnym narzędziem jest opisywany na blogu Apache Flume http://bigdatapassion.pl/categories/apache-flume/. Narzędzie strumieniuje dane z wielu źródeł do wielu lokalizacji.

Apache Nifi

https://nifi.apache.org/

Coraz częściej spotkamy Apache Nifi jako zamiennik / następca, który obsługuje dużą liczbę komponentów. Nifi zarządza przepływem informacji pomiędzy różnymi systemami, łączy je i zarządza ich dalszym losem.

Apache Oozie

https://oozie.apache.org/

Tu Apache Oozie dobrze współpracuje pomiędzy zasobami przechowywania danych (storage) a bazami danych w różnych kombinacjach. Przykładem jest zrównoleglony odczyt danych z HBase i zapis na HDFS.

Podsumowanie

Do całości można dodać funkcjonalność tworzenia migawek snapshot, która jest demonem prędkości podczas przywracania danych po awarii. Pamiętajmy, że to nadal nie jest pełnoprawna kopia zapasowa, gdyż nie zastąpuje to Disaster Recovery (DR).

Big Data Technology Warsaw Summit 2020

Mon, 16 Dec 2019 00:00:00 +0000

Jesteś pasjonatem Big Data, Data Science, inżynierii i monetyzacji danych, przetwarzania danych w czasie rzeczywistym?

27 lutego 2020, w Warszawie, jedyna taka okazja w roku - duża międzynarodowa konferencja - Big Data Technology Warsaw Summit 2020.

W 6. edycji weźmie udział ponad 500 uczestników - nie możesz tego przegapić!

Duża część prelegentów przybędzie z zagranicy, zaś wszyscy to wybitni fachowcy – inżynierowie, architekci, deweloperzy. Podzielą się doświadczeniem zdobytym przy wyjątkowo ciekawych projektach – w takich firmach jak Alibaba, Amazon Web Services, Booking.com, Orange, Philip Morris International, Zalando i in.

Konferencja jest praktyczna i technologiczna – towarzyszą jej dwa dni warsztatów do wyboru:

Developing production-ready Spark application
Real-Time stream processing
Big Data on Kubernetes

A dla zapracowanych i zabieganych 4-godzinne tutoriale - pigułka mocno skoncentrowanej wiedzy:

Detect, capture, and ingest changed data from RDBMS to Hadoop
From event to insights

Dołącz do uczestników konferencji i skorzystaj z promocji przy rejestracji do 19 grudnia!

Z kodem „BIgDataPassion” otrzymasz 10% rabatu na udział w konferencji!

Wszystkie informacje znajdziesz tutaj»>

Analiza danych w czasie rzeczywistym za pomocą Apache Kafka

Sat, 14 Dec 2019 00:00:00 +0000

Na kanale YouTube Confitury pojawiły się nagrania z tegorocznej konferencji.

Poniżej relacja:

oraz moja prezentacja:

II edycja What the H@ck (WTH)

Fri, 13 Dec 2019 00:00:00 +0000

Całe środowisko polskiego IT Security – musisz tu być!

W sobotę, 14 grudnia w Warszawie odbędzie się II edycja What the H@ck (WTH) – najważniejszej konferencji z obszaru polskiego IT Security adresowanej do osób zainteresowanych szeroko pojętym bezpieczeństwem IT.

Projekt wyróżnia przede wszystkim ciekawa, konkretna i bogata agenda. Będzie można znaleźć w niej aż 14 równoległych ścieżek, z takich obszarów jak i.in. red teaming (atak), blue teaming (obrona), zagadnienia architektoniczne, bezpieczeństwo instytucji finansowych, bezpieczeństwo rozwiązań typu cloud i mobile, trendy, ryzyko IT, czy zagadnienia prawne pod kątem bezpieczeństwa informatycznego. Łącznie będzie czekało na uczestników blisko sto konkretnych wystąpień, w których położyliśmy nacisk na wysokiej jakości wartość merytoryczną. Wystąpienia przygotowane są m.in. przez doświadczonych praktyków, ekspertów i konsultantów oraz przedstawicieli środowisk naukowych.

Na koniec dnia, zapewne spore grono uczestników, spotka się dodatkowo na oficjalnym afterparty. Będzie to okazji do poznania prelegentów i innych osób z branży – zwłaszcza, że całość odbywać się będzie w sobotę.

W takcie wydarzenia, uczestnicy będą mieli również możliwość odwiedzenia stoisk Sponsorów i Partnerów. Warto zobaczyć jakie produkty, usługi lub oferty rekrutacyjne oferują czołowe organizacji z obszaru IT Security.

Sponsorami wydarzenia są: Standard Chartered, Accenture, Microsoft, ING Tech, T-Systems, Samsung.

Organizatorami wydarzenia są: Zaufana Trzecia Strona, Fundacja Academic Partners.

Więcej informacji: https://www.WTHconf.pl

Apache Flume jako agregator strumieni danych

Tue, 19 Nov 2019 00:00:00 +0000

W środowiskach Big Data proces przejmowania jest często elementem całości przepływu ETL. Owe przejmowanie danych rozumiemy jako pobieranie treści z takich źródeł jak bazy danych czy pliki. Bardziej złożonymi formami (w większości przypadków) to źródła rzadziej używane na co dzień a więc NoSQL, maile, API, IoT, których skala, różnorodność i złożoność można opisać w dwóch słowach: Volume i Variety. Przy tak dużym surowcu danych naturalną decyzją jest przejście z modelu przetwarzania wsadowego na tryb czasu rzeczywistego (np. przy użyciu narzędzia Kafka). Dochodzimy do kolejnego V jakim jest Velocity: czas, prędkość i zmienność. Czwartym elementem opisywanych danych jest Veracity: jakość, pewność i pochodzenie. I tu wkradają się kolejne wyzwania, gdzie należy stawić czoła: niedokładności danych, niekompletności, niespójności, wątpliwej (nieopisanej) wiarygodności czy nieprawdziwości. Wynik eksploracji danych jest mocno zależny od ich jakości.

Apache Flume i podobne rozwiązania

Flume to projekt Apache Software Foundation, jest opisany jako usługa agregowania danych, która jest: rozproszona, niezawodna i dostępna. Flume jest bardzo elastyczny (umożliwia wiele idei wdrażania) i umożliwia przesyłanie dużych ilości danych (ruch sieciowy, dane społecznościowe, logi) co daje dużo możliwości dostosowania do środowiska. Należy uwypuklić dużą konfigurowalność narzędzia, aplikacja nie ogranicza się tylko do agregacji danych. Przykład, jeśli musimy wdrożyć dane dziennika (tekstowe) do Hadoopa/HDFS to Flume jest odpowiednim narzędziem.

Ograniczeniem wielkości tego bytu jest (technicznie) możliwość zapisu go w przestrzeni dyskowej czy pamięci. Należy zwrócić uwagę, że aplikacja stworzona jest do ciągłego przetwarzania danych, lecz brak tej stabilności strumienia danych nie powoduje problemów w jej funkcjonowaniu.

Warto zarekomendować, że ze względu na swą łatwość konfiguracji Flume jest uwielbianym konstruktorem logów a uznawanie go za ‘realtime data processors’ jest jednym z jego funkcjonalności. Popularność zawdzięcza faktowi, że było to jedne z pierwszych narzędzi do gromadzenia danych w Hadoopie. Flume też ma swoją smutniejszą stronę, jest wypierany przez inne narzędzia (np. takie jak NiFi) i zasadność wdrożenia tej technologi należy poprzedzić analizą a więc zainwestować czas na prześledzenie innych dostępnych rozwiązań.

Podobne technologie to:

Sqoop (hadoop <-> RDBMS)
Oozie (natywne hadoopowe narzędzie do uporządkowania ETL)
NiFi (zarządza i kontroluje przepływy z obsługą myszki - GUI)

Technicznie o Flume

Flume jest zaprojektowany do transportu i przetwarzania regularnie generowanych danych zdarzeń w relatywnie stabilnych, potencjalnie złożonych topologiach. Jak już jesteśmy przy zdarzeniach to je zdefiniujmy jako ciąg znaków (bajtów). Przykładem może być wcześniej wspomniany wpisu logu (tekst) lub obrazek. Reguralnie generowane dane możemy przedstawić jako strumienie danych.

Wymagania systemu ograniczają się tylko do:

jdk 1.8+
większej ilości pamięci - w zależności od wielkości przetwarzanych zasobów
powierzchnia dyskowa na składowanie danych

Przepływ danych

Flum definiuje 3 parametry, które trywialnie można je opisać wg ich przeznaczenia:

Source

konfiguracja danych wejściowych

Channel

proces przetwarzania (przeskok)

Sink

rozdzielenie danych wyjściowych

Składnia w pliku konfiguracyjnym

Aranżacja w pliku:

<Agent>.sources.<Source>.<someProperty> = <someValue>
<Agent>.channel.<Channel>.<someProperty> = <someValue>
<Agent>.sources.<Sink>.<someProperty> = <someValue>

Podsumowanie teorii

Zdarzenie Flume jest zdefiniowane jako jednostka przepływu danych posiadająca ładunek bajtów i opcjonalny zestaw atrybutów ciągu. Agent Flume to proces (JVM), który hostuje komponenty, przez które zdarzenia przepływają ze źródła zewnętrznego do następnego miejsca docelowego (przeskoku). Kropka.

Przygotowanie środowiska

Posłużymy się oraclowym JDK8 (opisane w poprzednich artykułach, więc nie powielamy treści) i Flume w wersji 1.9.0, gdzie możemy pobrać ze strony ftp.man.poznan.pl. Zwróćmy uwagę na weryfikację pobranych treści, ale po kolei.

Po właściwej instalacji Java Developer Kit powinniśmy otrzymać wynik polecenia sprawdzającego wersje javy java -version tak jak poniżej.

java version "1.8.0_221"
Java(TM) SE Runtime Environment (build 1.8.0_221-b11)
Java HotSpot(TM) 64-Bit Server VM (build 25.221-b11, mixed mode)

Na maszynie, która będzie nam służyła jako agent tworzymy katalog /opt-dev i w nim pobieramy aplikacje.

root@host104:~# mkdir /opt-dev
root@host104:~# cd /opt-dev
root@host104:/opt-dev# wget http://ftp.man.poznan.pl/apache/flume/1.9.0/apache-flume-1.9.0-bin.tar.gz
--2019-10-21 20:54:57--  http://ftp.man.poznan.pl/apache/flume/1.9.0/apache-flume-1.9.0-bin.tar.gz
Resolving ftp.man.poznan.pl (ftp.man.poznan.pl)... 150.254.173.17, 2001:808::173:17
Connecting to ftp.man.poznan.pl (ftp.man.poznan.pl)|150.254.173.17|:80... connected.
HTTP request sent, awaiting response... 200 OK
Length: 67938106 (65M) [application/x-gzip]
Saving to: 'apache-flume-1.9.0-bin.tar.gz'

apache-flume-1.9.0-bin.tar 100%[======================================>]  64.79M  4.89MB/s    in 13s     

2019-10-21 20:55:10 (4.86 MB/s) - 'apache-flume-1.9.0-bin.tar.gz' saved [67938106/67938106]

Teraz pobieramy pliki, które posłużą nam jako zbiory do porównania pobranej binarki z flumem oraz klucz.

# wget -q http://www.apache.org/dist/flume/1.9.0/apache-flume-1.9.0-bin.tar.gz.sha512
# wget -q http://www.apache.org/dist/flume/1.9.0/apache-flume-1.9.0-bin.tar.gz.asc
# wget -q http://www.apache.org/dist/flume/KEYS -O asf_keys

Korzystając z polecenia wget posłużyliśmy się przełącznikiem -q tylko dlatego, aby zaśmiecać wpisów zbędnymi informacjami.

Nasz katalog powinien posiadać trzy pliki

root@host104:/opt-dev# tree -a /opt-dev/
/opt-dev/
|-- apache-flume-1.9.0-bin.tar.gz
|-- apache-flume-1.9.0-bin.tar.gz.asc
|-- apache-flume-1.9.0-bin.tar.gz.sha512
`-- asf_keys

0 directories, 4 files

Mamy już wszystko, importujemy klucze deweloperów.

root@host104:/opt-dev# gpg --import asf_keys 
gpg: key CD14AD58901791C2: public key "Eric Sammer <esammer@apache.org>" imported
...
gpg: Total number processed: 9
gpg:               imported: 9

Dla każdego autora mamy zapis mówiący o zaimportowaniu public key "Ktoś Tam <jego@e-mail>" imported" jego klucza do bazy. Zauważmy, że przy kolejnym imporcie mamy już informację, że klucz nie został ponownie dodany not changed - dzieje się to w sytuacji, gdy już wcześniej w naszej bazie mieliśmy już wpis, przykład poniżej.

root@host104:/opt-dev# gpg --import asf_keys 
gpg: key CD14AD58901791C2: "Eric Sammer <esammer@apache.org>" not changed
...
gpg: Total number processed: 9
gpg:              unchanged: 9

Sposobów weryfikacji jest kilka i zostały opublikowane na stronie pobierania. Czas rozpakować paczkę i powinniśmy otrzymać podobną strukturę jak poniżej.

root@host104:/opt-dev# tar zxf apache-flume-1.9.0-bin.tar.gz
root@host104:/opt-dev# tree -L 2 -a /opt-dev/
/opt-dev/
|-- apache-flume-1.9.0-bin
|   |-- bin
|   |-- CHANGELOG
|   |-- conf
|   |-- DEVNOTES
|   |-- doap_Flume.rdf
|   |-- docs
|   |-- lib
|   |-- LICENSE
|   |-- NOTICE
|   |-- README.md
|   |-- RELEASE-NOTES
|   `-- tools
|-- apache-flume-1.9.0-bin.tar.gz
|-- apache-flume-1.9.0-bin.tar.gz.asc
|-- apache-flume-1.9.0-bin.tar.gz.sha512
`-- asf_keys

6 directories, 11 files

W katalogu conf znajdują się pliki konfiguracyjne, które możemy wykorzystać. Tworzymy kopie plików z dopiskiem .template.

# cd apache-flume-1.9.0-bin
# pwd
/opt-dev/apache-flume-1.9.0-bin
# cp conf/flume-conf.properties.template conf/flume-conf.properties
# cp conf/flume-env.ps1.template conf/flume-env.ps1
# cp conf/flume-env.sh.template conf/flume-env.sh

Po wskazanych działaniach zawartość katalogu konfiguracji powinna być podobna do poniższego schematu.

root@host104:/opt-dev/apache-flume-1.9.0-bin# tree conf/
conf/
|-- flume-conf.properties
|-- flume-conf.properties.template
|-- flume-env.ps1
|-- flume-env.ps1.template
|-- flume-env.sh
|-- flume-env.sh.template
`-- log4j.properties

0 directories, 7 files

Na potrzeby tego ćwiczenie należy utworzyć strukturę katalogów na hdfs. Owe miejsce będzie służyło do zapisów wyników działania flume.

# hdfs dfs -mkdir -p /bigdata/flume/cw1
# hdfs dfs -ls -R /
drwxr-xr-x   - root supergroup          0 2019-10-21 22:34 /bigdata
drwxr-xr-x   - root supergroup          0 2019-10-21 22:34 /bigdata/flume
drwxr-xr-x   - root supergroup          0 2019-10-21 22:34 /bigdata/flume/cw1

Dodajemy pierwsze zapiski mówiące co i gdzie należy wrzucać dane do flume-conf.properties

passion0x00.sources                              = src0x00
passion0x00.sinks                                = snk0x00
passion0x00.channels                             = chn0x00
passion0x00.sources.src0x00.channels             = chn0x00
passion0x00.sinks.snk0x00.channel                = chn0x00
passion0x00.sinks.snk0x00.type                   = HDFS
passion0x00.sinks.snk0x00.fileType               = DataStream
passion0x00.sinks.snk0x00.hdfs.path              = hdfs://h3host200.bigdatalinux.com:8020/bigdata/flume/cw1
passion0x00.sinks.snk0x00.hdfs.filePrefix        = infoout
passion0x00.sinks.snk0x00.hdfs.writeFormat       = Text
passion0x00.sinks.snk0x00.hdfs.rollInterval      = 0
passion0x00.sinks.snk0x00.hdfs.rollSize          = 0
passion0x00.sinks.snk0x00.hdfs.rollCount         = 1000
passion0x00.sinks.snk0x00.hdfs.batchSize         = 100
passion0x00.sinks.snk0x00.hdfs.useLocalTimeStamp = true
passion0x00.sinks.snk0x00.hdfs.callTimeout       = 180000
passion0x00.channels.chn0x00.type                = memory
passion0x00.channels.chn0x00.capacity            = 256
passion0x00.channels.chn0x00.transactionCapacity = 128
passion0x00.sources.src0x00.type                 = org.apache.flume.source.StressSource
passion0x00.sources.src0x00.size                 = 512
passion0x00.sources.src0x00.maxTotalEvents       = 2048
passion0x00.sources.src0x00.batchSize            = 1
passion0x00.sources.src0x00.maxEventsPerSecond   = 128

Powyższa konfiguracja dla danych wejściowych ustawia losowe znaki z dużym limitem, aby nie zapełnić zbędnymi danymi HDFS-a. Co prawda użyłem org.apache.flume.source.StressSource, które służy do przeprowadzania testów wydajnościowych, lecz takie rozwiązanie jest najprostsze tj. out-of-the-box.

Zapis następuje na katalog na Hadoopie wraz z kilkoma parametrami, które są opcjonalne. Pomocny może się okazać passion0x00.sinks.snk0x00.hdfs.callTimeout w którym określamy czas oczekiwania na potwierdzenie transakcji zapisu.

Pozostaje nam tylko uruchomić na kilka minut a następnie zabić agenta flume. Gdyby wystąpiły problemy z wystartowaniem usługi można się wspomóc dodatkowym przełącznikiem flume.root.looger=DEBUG,console.

time bin/flume-ng agent \
     -n passion0x00 -c conf \
     -f conf/flume-conf.properties

W katalogu /bigdata/flume/cw1 powinniśmy zobaczyć kilka plików.

$ hdfs dfs -ls /bigdata/flume/cw1
Found 3 items
-rw-r--r--   2 hdfs hdfs     531286 2019-10-22 23:31 /bigdata/flume/cw1/infoout.1571779877530
-rw-r--r--   2 hdfs hdfs     531286 2019-10-22 23:31 /bigdata/flume/cw1/infoout.1571779877531
-rw-r--r--   2 hdfs hdfs      25594 2019-10-22 23:31 /bigdata/flume/cw1/infoout.1571779877532.tmp

Nie działa?

W moim przypadku miałem problemy z połączeniem do HDFS-a w wersji 3.2.1 (wydanie z 22. września 2019). Problem wynikał z m. in. z brakiem nowszej wersji pliku jar odpowiedzialnego za komunikacje z DFS. Test przeprowadzone na hadoop 2.9.2 (19. listopada 2018) dały już pożądane rezultaty. Warto zaznajomić sie z https://www.ietf.org/rfc/rfc2119.txt a następnie ze zdaniem Apache Hadoop revisions SHOULD retain binary compatability such that end-user applications continue to work without any modifications - to daje nam ogólny pogląd na nasze problemy :)

Na zakończenie. Zadanie było wykonywane na kilku środowiskach, stąd nie należy sie sugerować nazwa hosta czy GID/UID na wylistowanych przykładach.

Poświadczenia i ogólne zasady bezpieczeństwa w AWS - wstęp

Fri, 19 Jul 2019 00:00:00 +0000

Poświadczenie

Poświadczenie to pewien zestaw uprawnień obiektu, który legitymuje się przy dostępie do wybranych zasobów. Najprostszy scenariusz to przypisanie pewnemu użytkownikowi takich uprawnień, które pozwolą mu wykonać pewne operacje na pewnych zasobach.

Poświadczenia bezpieczeństwa w AWS

Dla możliwości zarządzania Amazon Web Services należy uwierzytelnić się za pomocą:

nazwa użytkownika i hasło (do konsoli zarządzania)
klucze dostępu do AWS API lub AWS CLI

Pierwsza metoda jest dostępna przy pierwszym logowaniu. Po poprawnym zalogowaniu można rozpocząć zabezpieczanie konta i używać innych sposobów logowania. Prócz wspomnianego wyżej pierwszego sposobu (e-mail/hasło) istnieje też dostęp po kluczach do interfejsu zarządzania. Wygenerowane klucze moża dopisać do konfiguracji takich narzędzi jak np. Ansible (wraz z boto/boto2/boto3), dzięki czemu powstaje fajnie zautomatyzowane całe środowisko :).

Przykładem dla Ansible może być zakładanie nowej instancji EC2 za pomocą poniższego playbooka:

- ec2:
    key_name: marcin_gnulinux_public_key
    instance_type: t2.micro
    image: ami-numerek
    group: webserver
    wait: yes
    count: 4
    vpc_subnet_id: subnet-319fc37a
    assign_public_ip: yes

Należy zwrócić uwagę na dbałość tzn. o bezpieczne przetrzymywanie kluczy, jeśli zapomni się lub straci dane uwierzytelniające, nie można ich już odzyskać. Nie można ich odzyskać, ale można je ponownie wygenerować :).

Poświadczenie użytkownika root konta AWS jest inne niż uzyskanie poświadczenia użytkownika IAM.

dla konta root uzyskasz poświadczenia z Security Credentials w AWS Management Console
dla kont IAM uzyskasz poświadczenia z IAM

Typy poświadczeń

Adres e-mail i hasło

Tożsamość tworzona jest przy pierwszym dostępie do konsoli AWS - podczas tworzenia konta. Tożsamość ma pełny dostęp do wszystkich usług AWS i zasobów na koncie. Nosi nazwę Root User.

Zalecane jest nie używanie tego konta do prac administracyjnych na co dzień. Do tego celu należy utworzyć nowe konto z uprawnieniami administratora w IAM (Identity and Access Management). Po utworzeniu nowego użytkownika należy zabezpieczyć konto root tak, aby korzystać z niego tylko w zarządzaniu kontem i usługami.

Użytkownik root posiada najwyższy poziom dokonywania zmian na koncie AWS:

Zarządzanie Root User
Zmiana planu AWS
Edycja sposobów płatności
Sprawdzanie bilingu
Zgłaszanie zapytań dot. finansów
Wyłączenie konta
Logowanie do GovCloud
Konfiguracja Reverse DNS dla EC2
Tworzenie pary kluczy CloudFront
Zmiana ID dla instancji EC2
Konfiguracja MFA dla koszyków S3
Edycja/usuwanie koszyków S3 dla VPC ID lub VPC endpoint ID
Żądanie przeprowadzenia pentestów
Wyłączenie ograniczenia ruchu na 25/tcp dla EC2
Pokazanie w kanonicznej postaci nasz ID
Przywracanie uprawnień użytkownika IAM
Zmiana danych kontaktowych, waluty

Ciekawe jest, że jako nie-root (jako użytkownik IAM) też można zażądać przeprowadzenie testów penetracyjnych, ale za pomocą e-maila. Konto root potrafi to zrobić dodatkowo za pomocą web form.

Użytkownicy IAM podają swoje nazwy użytkowników i hasła, gdy logują się do:

konsoli AWS Management Console
forum dyskusyjnego AWS
centrum wsparcia AWS

W niektórych przypadkach nazwa użytkownika i hasło IAM są wymagane do korzystania z usługi, takiej jak wysyłanie wiadomości e-mail za pomocą SMTP za pomocą usługi Amazon Simple Email Service (Amazon SES).

Użytkownik IAM nie może dokonać zmiany hasła, chyba że otrzymał poświadczenia.

Multi-Factor Authentication (MFA)

Wieloetapowe uwierzytelnianie (MFA) zapewnia dodatkowy poziom bezpieczeństwa, który można zastosować (dodać) do konta AWS. Aby zapewnić dodatkowe bezpieczeństwo, zaleca się wymaganie dostępu MFA do poświadczeń użytkownika root konta AWS i wysoce uprzywilejowanych użytkowników IAM.

Po włączeniu MFA, po zalogowaniu się na stronie AWS pojawi się monit o podanie nazwy użytkownika i hasła oraz kodu uwierzytelniającego z urządzenia MFA co zapewnia większe bezpieczeństwo ustawień konta AWS i zasobów. Domyślnie MFA nie jest włączone.

Limit na ilość urządzeń MFA na dla użytkownika IAM i konto root wynosi: 1

Access Keys (Access Key ID and Secret Access Key)

Klucze dostępu składają się z dwóch części:

identyfikator klucza dostępu (na przykład AKIAIOSFODNN7EXAMPLE)
tajny klucz dostępu (na przykład wJalrXUtnFEMI / K7MDENG / bPxRfiCYEXAMPLEKEY)

Używamy ich do:

podpisywania żądań programowych komend AWS CLI (używając SDK)
autoryzacji przy korzystaniu z interfejsu AWS API

Do Uwierzytelnienia żądań należy użyć:

identyfikatora klucza dostępu
tajnego klucza dostępu

Podczas tworzenia kluczy dostępu tworzymy zestaw składający się z:

identyfikator klucza dostępu
tajny klucz dostępu

Tylko przy tworzeniu mamy możliwość pobrania części klucza dostępu (tajnego klucza dostępu). Nie ma możliwości ponownego zobaczenia tych danych, wtedy należy ponownie wygenerować zestaw kluczy dostępu.

W przypadku zagubienia tych informacji też tworzymy ponownie zestaw kluczy. Nowo utworzony klucz ma status aktywny tj. można z niego korzystać a więc posługiwać się nim w komunikacji z AWS API lub za pomocą AWS CLI.

Dla głównego użytkownika root można przypisać maksymalnie dwa klucze. Nawet wyłączony (nieaktywny) klucz wlicza się do limitu.

Istnieją tymczasowe klucze dostępu - tymczasowe poświadczenia bezpieczeństwa. Oprócz identyfikatora klucza dostępu i tajnego klucza dostępu tymczasowe poświadczenia bezpieczeństwa obejmują token bezpieczeństwa, który należy wysłać do AWS podczas korzystania z tymczasowych poświadczeń bezpieczeństwa.

Zaletą tymczasowych poświadczeń bezpieczeństwa jest to, że są one krótkoterminowe. Po wygaśnięciu nie są już ważne. Można używać tymczasowych kluczy dostępu w mniej bezpiecznych środowiskach lub rozpowszechniać je, aby zapewnić użytkownikom tymczasowy dostęp do zasobów na koncie AWS.

Key Pairs

Pary kluczy nie są powiązane z kluczami dostępu. Składają się z klucza publicznego i klucza prywatnego.

Do utworzenia podpisu cyfrowego używamy klucza prywatnego, a następnie AWS używa odpowiedniego klucza publicznego do sprawdzenia poprawności podpisu.

Pary kluczy są używane tylko dla:

Amazon EC2
Amazon CloudFront

Dla EC2 używamy do dostępu do instancji po SSH.

Dla CloudFront do tworzenia podpisanych adresów URL dla treści prywatnych. Dla przykładu gdy chcemy rozpowszechniać treść, za którą ktoś zapłacił.

AWS nie udostępnia par kluczy dla naszego konta - musimy je stworzyć. Tylko użytkownik root konta AWS może tworzyć pary kluczy CloudFront.

Alibaba Cloud - duży gracz na rynku Cloud Computing

Sat, 15 Jun 2019 00:00:00 +0000

Kilka słów o Alibaba Group

Grupa Alibaba powstała w 1999 roku. Obecnie zatrudnia ok. 93 tyś. pracowników. Nazwa firmy pochodzi od Ali Baby - postać z bliskowschodniej kolekcji opowiadań ludowych One Thousand and One Nights i powstała ze względu na jej uniwersalny wygląd. Logo Grupy (źródło: https://www.alibabagroup.com/en/global/home)

Kilka słów o Alibaba Cloud (Aliyun / AliCloud)

Niebawem dziesięciolecie (wrzesień 2019) platformy Alibaba Cloud. Platforma chmury obliczeniowej Alibaba ma ponad 50% udziału w rynku w Chinach (luty 2019, źródło: https://www.fool.com). Logo firmy zapisane w języku ojczystym:

Usługi Cloud dostępne są dla nas od 2014 roku a w listopadzie 2016 powstał pierwszy w Europie rejon w Frankfurcie.

Ważniejsze usługi

W skrócie jak wyglądają oferta Alibaba Cloud.

Gałąź technologi	Opis
Elastic Computing	Usługi wykorzystujące moce obliczeniowe, równoważenie obciążenia, (zaawansowane) możliwości sieciowe
Storage & CDN	Przechowuje i udostępnia duże ilość danych i obiektów za pomocą zarządzanych produktów do przechowywania i dostarczania treści
Networking	Twórz i zabezpieczaj sieci dla swoich usług (np. Cloud VPC, ExpressConnect
Database Services	Zarządzanie bazami danych
Security	Ochrona danych, aplikacji i serwerów przed złośliwymi atakami
Monitoring & Management	Zarządzaj i monitoruj w czasie rzeczywistym dedykowanymi do tego narzędziami
Domains & Website	Obsługa domen i DNSa Alibaba Cloud
Analytics & Big Data	Narzędzia do analityki hurtowni danych, analiza biznesowa, przetwarzanie wsadowe, przetwarzanie strumieniowe, uczenie maszynowe i rozwiązania Big Data
Application Service	Komponenty i narzędzia do zarządzania i tworzenia aplikacji i zarządzanie nimi
Media Services	Platforma to przetwarzania dźwięku i obrazu (video)
Middleware	Rozwiązania mikroserwisowe i wdrażanie aplikacji
Cloud Communication	Usługa Short Message Service
Apsara Stack	Połączenie naszego onpremisowego środowiska z Alibabą
Internet of Things	Dwa narzędzia IoT Platform i IoV Command Center

Rozpoczęcie pracy - tworzenie konta

Możemy utworzyć konto na dwa sposoby:

za pomocą witryny internetowej
za pomocą aplikacji

Dzisiaj utworzymy sobie konto pierwszym sposobem (za pośrednictwem strony www). Przy rejestracji na pierwszym ekranie uzupełniamy:

Pole	Wartość	Uwagi
Kraj	Poland	Należy mieć na uwadze, że po zatwierdzeniu naszego wyboru nie ma możliwości zmiany tego parametru
Email	marcin@gnulinux.pl	Zostanie wysłana informacja o rejestracji
Password	tAJn3_Haa$#o7_max20	Maksymalnie 20 znaków :/
Confirm	tAJn3_Haa$#o7_max20	Potwierdzamy wpisując ponownie to samo hasło

Należy pamiętać o wyrażeniu zgody - zatwierdzeniu regulaminu.

Po zatwierdzeniu wyświetli nam się okienko z prośbą o przepisanie sześcio-cyfrowego kody weryfikującego poprawność naszego adresu e-mail. Po weryfikacji otrzymamy kolejnego maila z informacją o utworzeniu konta.

Już od teraz mamy dostęp do konsoli Alibaba Cloud. Kolejnym etapem będzie włączenie:

wieloetapowej autoryzacji (MFA)
ograniczenie dostępu do konsoli na podstawie listy dozwolonych adresów IP

Weryfikacja TOTP

W prawym górnym rogu strony www wybieramy z menu Account Management

Wieloetapowa autoryzacja (MFA) tutaj widnieje w pozycji Account Protection jako weryfikacja TOTP (Time-based One-Time Password algorithm).

Opisywana konfiguracja zwiększa bezpieczeństwo. Polega na dodaniu do naszej aplikacji na telefonie / tablecie / laptopie / komputerze / pralce kodu (który jest ciągiem znaków znanym tylko Tobie i serwerowi). W większości przypadków nasza aplikacja zeskanuje obrazek z kodem QR w którym jest zawarty wspomniany kod. W przypadku problemów (zeskanowanie kodu jest niemożliwe lub aplikacja kliencka nie ma takiej funkcjonalności) można go przepisać. Otrzymany w ten sposób wpis w naszej aplikacji generuje kod autoryzacyjny co 30 sekund i powstaje z kodu oraz bieżącego znacznika czasu.

Uogólniając:

qwertyKODqwerty + 1234CZAS56789 = 123456

Generowanie odbywa się jednocześnie po stronie klienta (nas) jak i po stronie serwera (usługi do której się logujemy). Większość aplikacji generuje 6-cio cyfrowy ciąg znaków, lecz jest możliwość otrzymania ośmio-cyfrowej kombinacji (zależy to od konfiguracji usługi przez serwis). Na urządzenia mobilne polecam aplikację FreeOTP, ponieważ:

Open Source
obsługa HOTP i TOTP
dodawanie za pomocą kodu QR lub wpisanie kodu ręcznie
licencja Apache 2.0
wspierany przez Red Hat-a
wspiera iOS-a i Android-a
klarowny interfejs i intuicyjna obsługa
więcej w repo: https://github.com/freeotp

Osoby zaciekawione tematem zachęcam do lektury (kolejność losowa):

Włączenie dodatkowej ochrony

W Account Protection wybieramy Edit

W formularzu zaznaczamy poniższe opcje:

Obszary wymagające ochrony

logowanie do konta
zmiana danych konta

Metoda weryfikacji

TOTP

Istnieje możliwość weryfikacji za pomocą kodu SMS, lecz owe rozwiązanie (w mojej ocenie) jest zawodne i mniej bezpieczne.

Po otrzymanie komunikatu o podobnej treści:

Verification in progress m^^^^@gnulinux.pl Enable TOTP Please select the method of verification

Wybieramy By Email Verification. Na poczcie otrzymamy sześcio-cyfrowy kod, który przepisujemy do interfejsu webowego i zatwierdzamy klawiszem Submit.

Jeśli wcześniej podaliśmy numer telefony to automatycznie pojawi się dodatkowa możliwość weryfikacji za pomocą SMS-a (zdjęcie poniżej)

Na kolejnym ekranie jest propozycja zainstalowania Google Authenticator, lecz pomijamy ten krok (mając zainstalowaną inną aplikację obsługującą TOTP, np FreeOTP) wybierając Next.

Kolejny ekran wyświetli nam kod QR oraz możliwość wpisania z palca kodu - opcja znajduje się pod niebieskim linkiem Scan failed?.

Po zeskanowaniu QR-a (dodaniu do aplikacji) należy przepisać wygenerowany kod i zatwierdzić.

Konfiguracja zakończona. Od teraz przy każdym logowaniu będą wymagane poniższe dane:

login (e-mail)
hasło (podane przy rejestracji)
sześcio-cyfrowy ciąg znaków z aplikacji

Zaufane adresy IP

Chcąc zwiększyć swoje bezpieczeństwo podczas prób logowania dodatkowo należy podać listę adresów IP. Owe adresy pozwolą na zalogowanie się do konsoli (interfejsu webowego). Konfiguracja jest bardzo prosta i ogranicza się do podania jednego / wielu adresów oddzielonych średnikiem (;).

Tak jak wcześniej w prawym górnym rogu strony www wybieramy z menu Account Management

Wybieramy Set w pozycji opisanej jako Login Mask

Zgodnie z instrukcją w pole wpisujemy nasze adresy IP z których jesteśmy widoczni w sieci.

Zwróć uwagę, że przy zmiennym IP w domu po zmianie przez ISP Twojego adresu logowanie nie będzie możliwe.

Tutaj proponuję wpisać kilka adresów, aby ustrzec się przed odcięciem sobie możliwości zalogowania.

Adres IP z domku (jeśli mamy stałe zewnętrzne IP)
Adres IP / pula adresów z naszej firmy (jeśli takowe posiada)
Adresy IP kilku naszych VPS-ów / serwerów dedykowanych

Teraz wystarczy zatwierdzić i zmianą są już widoczne w panelu.

Podsumowanie

Krótko: Alibaba Cloud to ciekawa konkurencja dla innych dużych dostawców.

W kolejnym artykule zrobimy podłączenie konta PayPal.

Relacja z konferencji Oracle Cloud Day w Warszawie

Wed, 12 Jun 2019 00:00:00 +0000

21 maja 2019 roku byliśmy na konferencji o chmurze zorganizowanej przez Oracle. Nie sposób było być na każdej z czterech ścieżek tematycznych w całości, ale się staraliśmy :)

Konforencję otworzył Pan Piotr Witczyński (Vice President Consulting Eastern Europe & CIS). Z ciekawostek w 2013 roku po 5-letniej kadencji został ponownie powołany na dyrektora generalnego. Jego współpraca z firmą Oracle trwa już 20 lat.

Do przerwy obiadowej (11:30) na sesji plenarnej mieliśmy okazje wysłuchać:

Temat wystąpienia	Prelegent
The future is autonomus	Andrew Sutherland (dołączył do firmy w 1995 roku)
Automatyzacja śledzenia postępów w projektach budowlanych	Paweł Kobojek (AI Leader, AI Clearing, ponad 30 lat doświadczenia)
Sztuczna inteligencja czym jest, jak z sukcesem wdrożyć i odzyskać wartość	dr Andrzej Wodecki (adiunkt na PW na Wydziale Zarządzania)

Po smacznej uczcie dla ciała a dla ducha rozmowach rozpoczęły się 4 ścieżki:

Sesja biznesowa
Sesja techniczna
Warsztaty
Aplikacje

Najbardziej zaciekawiły mnie oczywiście warsztaty, gdzie znalazłem dla siebie miejsce spośród +50 innych uczestników. Tematem naszych zmagań przed laptopami było tworzenie aplikacji “Cloud Native” w Oracle Cloud Infrastructure. Podczas wykonywania ćwiczeń można zaobserwować mnogość usług i możliwości co bardzo mnie uskrzydla - lubię wiedzieć:). Początek był bardzo prosty, lecz później zaczęły się schody. Na warsztatach było pięć tematów do rozwiązania:

Lab 100: Konfiguracja środowiska deweloperskiego z użyciem github i Wercker

Lab 200: Tworzenie klastra k8s i utworzenie CI/CD dla wypychania aplikacji

Lab 300: Poprawianie błędów (bug fix) w aplikacji

Lab 400: Wprowadzenie nowych wersji aplikacji stosując wzorzec “blue-green”

Lab 500: Rozszerzanie aplikacji o nowe funkcje

Duża liczba osób zainteresowanych warsztatami i ograniczony czas nie pozwolił wykonać wszystkich ćwiczeń. Ruszyłem na pozostałe prelekcje, aby nic mnie nie ominęło. Obojętnie obok rozrywki nigdy nie przejdę, można było np. podziwiać na torze samochodziki - autonomiczne mini autka czy podziwiać budowle - model inteligentnego miasta zbudowany z klocków Lego :)

Konferencja miała dodatkowy plus - networking, a dzięki spotkaniu i porozmawianiu z kilkoma ciekawymi osobami otworzyły się ciekawe pomysły na lepsze wykorzystanie chmur.

Żródła

Część materiałów (zdjęcia) zostały pobrane ze strony https://oracle.com

Big Data i sztuczna inteligencja na konferencji Confitura 2019

Wed, 05 Jun 2019 00:00:00 +0000

Po raz kolejny odbywać się będzie jedna z największych i moim zdaniem zarazem najlepszych polskich konferencji, czyli Confitura. Po raz drugi będzie miała specjalną oddzielną ścieżkę Big Data and Artificial Intelligence.

Confitura jest konferencją poświęconą środowisku Java, stąd jest znana przede wszystkim programistom wykorzystującym do swej pracy Maszynę Wirtualną Java, czyli np. programistom takich języków jak Java, Scala, Kotlin czy Groovy. Wcześniej konferencja znana była pod nazwą Javarsowia.

Ścieżka Big Data and Artificial Intelligence pojawia się na niej po raz pierwszy w 2018 roku i na tyle dobrze została przyjęta że tradycja jest kontynuowana. To bardzo dobra wiadomość, gdyż coraz więcej uczestników konferencji to osoby pracujące na codzień z rozwiązaniami Big Data jako inżynierowie danych, data scientists oraz data architekci.

Tych co nigdy nie byli na Confiturze, gorąco zachęcam do udziału. Konferencja jest darmowa, jednak z powodu ogromnej liczby chętnych, wprowadzono licytacje drobnych cegiełek charytatywnych w zamian za możliwość otrzymania biletu wstępu.

Jeśli chcielibyście zobaczyć jak było na poprzednich edycjach, polecam kanał konferencji na YouTube.

Zapraszam także przy okazji na moją prezentację poświęconej Kafka Streams :)

Przegląd narzędzi i bibliotek do data science i sztucznej inteligencji (beta)

Thu, 30 May 2019 00:00:00 +0000

Wraz ze wzrostem popularności rozwiązań Data Science i Sztucznej Inteligencji, coraz więcej ludzi poszukuje odpowiednich bibliotek i narzędzi pozwalających realizować takie projekty.

Postanowiłem podzielić się swoją listą narzędzi i bibliotek które można użyć w tego typu projektach. Jeśli ktoś woli format arkusza, lista jest dostępna także tutaj. Jeśli uważasz, że warto dodać do tej listy jakieś narzędzie, proszę o informację na maila lub komentarz pod wpisem lub w arkuszu.

Nazwa	Strona	Kod żródłowy	Komentarz	Opis
Apache FlinkML	link	link	Szybko rosnąca popularność	Machine Learning (ML) library for Flink
Apache Hivemall	link	link	Inkubacja	Hivemall is a scalable machine learning library that runs on Apache Hive, Spark and Pig.
Apache Mahout	link	link		Free implementations of distributed or otherwise scalable machine learning algorithms
Apache MXNet	link	link	Inkubacja, szybko rosnąca popularność
Apache OpenNLP	link		Bardzo popularna	The Apache OpenNLP library is a machine learning based toolkit for the processing of natural language text
Apache SINGA	link	link
Apache Spark -> Databricks Deep Learning Pipelines for Apache Spark	link
Apache Spark -> MLlib	link	link	Bardzo popularna	MLlib is Apache Spark’s scalable machine learning library.
Caffe	link	link
Caffe2	link	link	Bardzo popularna	Convolutional Architecture for Fast Feature Embedding. A New Lightweight, Modular, and Scalable Deep Learning Framework
CatBoost	link	link
Chainer	link	link		Chainer is an open source deep learning framework written purely in Python on top of Numpy and CuPy Python libraries
DeepLearning4J	link	link		Deep learning programming library written for Java and the Java virtual machine (JVM)
Elephas	link			Distributed Deep Learning with Keras & Spark
Gluon		link		A clear, concise, simple yet powerful and efficient API for deep learning.
H2O	link	link	Bardzo popularna	Data Science and Machine Learning Platform
Horovod	link	link		Distributed training framework for TensorFlow, Keras, PyTorch, and MXNet.
Intel Analytics Zoo	link	link		A unified analytics + AI platform for distributed TensorFlow, Keras and BigDL on Apache Spark
Intel BigDL	link	link		BigDL is a distributed deep learning library for Apache Spark
Intel Data Analytics Acceleration Library (Intel DAAL)
Intel Math Kernel Library (Intel MKL)
Keras	link	link	Bardzo popularna	Keras is a high-level neural networks API, written in Python and capable of running on top of TensorFlow, CNTK, or Theano.
Keras -> Cern Distributed Keras	link		Nie rozwijana
MATLAB	link			Laboratorium Macierzy (MatrixLaboratory)
Microsoft Cognitive Toolkit (CNTK)
Natural Language Toolkit (NLTK)	link			zestaw bibliotek i programów do symbolicznego i statystycznego przetwarzania języka naturalnego
Neural Designer
ONNX (Open Neural Network Exchange)
OpenNN	link			OpenNN is a free neural networks library for advanced analytics.
PyTorch	link	link	Bardzo popularna	An open source deep learning platform that provides a seamless path from research prototyping to production deployment.
PyTorch -> AllenNLP	link
R Project	link		Popularny, traci na rzecz Pythona i innych języków	R is a free software environment for statistical computing and graphics
Scikit-learn	link			Machine Learning in Python
SciPy	link			Python library used for scientific computing and technical computing
SciPy -> IPython	link			A powerful interactive shell. A kernel for Jupyter.
SciPy -> Matplotlib	link			biblioteka do tworzenia wykresów dla języka programowania Python i jego rozszerzenia numerycznego NumPy
SciPy -> NumPy	link			NumPy is the fundamental package for scientific computing with Python
SciPy -> Pandas	link			library written for the Python programming language for data manipulation and analysis
SciPy -> Sympy	link			SymPy is a Python library for symbolic mathematics.
SciPy library	link			The SciPy library is one of the core packages that make up the SciPy stack
TensorFlow	link	link	Bardzo popularna
TensorFlow -> Yahoo TensorFlowOnSpark		link
Theano	link	link	Nie rozwijana	Theano is a Python library that allows you to define, optimize, and evaluate mathematical expressions involving multi-dimensional arrays efficiently
Torch	link	link	Nie rozwijana	A scientific computing framework for LuaJIT
XGBoost	link	link		XGBoost is an optimized distributed gradient boosting library designed to be highly efficient, flexible and portable.

Wprowadzenie weryfikacji wieloetapowej w Oracle Cloud

Mon, 20 May 2019 00:00:00 +0000

Dlaczego potrzebujemy wielopoziomowej autoryzacji?

W obecnych czasach ochrona za pomocą loginu i hasła nie jest już wystarczająco bezpiecznym sposobem dostępu do naszych usług. Wykradzione hasło daje dostęp osobom nieupoważnionym co kompromituje nasze dane. Właściwym zwiększeniem naszego spokoju jest np. wprowadzenie dodatkowej warstwy zabezpieczającej w postaci dwu etapowej autoryzacji. Dobrym sposobem jest uwierzytelnianie wielopoziomowe (multi-factor authentication MFA) za pomocą algorytmu TOTP (Time-based One-Time Password). Polega to na zalogowaniu się za pomocą loginu i hasła w kolejnym kroku wpisaniu tokena wygenerowanego przez aplikację / klucz sprzętowy. Rozwiązanie to wprowadza 2-warstwową autoryzację co znacząco utrudnia próbę przejęcia konta.

Token możemy otrzymać za pomocą SMS-a, e-maila lub z aplikacji zainstalowanej na telefonie czy tablecie. Ja używam i polecam FreeOTP (https://freeotp.github.io/).

Włączenie wieloetapowej autoryzacji w Oracle Cloud

Korzystając z menu burger (lewy górny róg strony) kolejno przechodzimy do ostatniej zakładki Governance and Administration a w niej Identity i Users. Wybieramy konto, które będzie używać dodatkowego zabezpieczenia logowania do naszego konta: klikamy na naszą nazwę lub wybieramy z menu ... pierwszą opcję View User Details.

Wybieramy Enable Multi-Factor Authentication i ukazuje nam się okienko z kodem QR oraz polem do wpisania wygenerowanego kodu.

Za pomocą aplikacji skanujemy kod QR (niebieska ikonka kodu QR tuż obok ikonki plusa).

Należy pamiętać, że raz wygenerowany kod QR nie można ponownie wyświetlić. Dla zachowania ‘HA’ robimy też skan na innym urządzeniu i w razie utraty / awarii jednego z nich nie tracimy dostępu do chmury.

Po zeskanowaniu uruchamiamy token stukając w jego ikonkę.

Nie należy się przejmować jeśli w ciągu 30 sekund nie zdążymy przepisać i zatwierdzić 6-cio cyfrowego kodu, ponieważ jest margines czasu, który zezwala na zatwierdzenie kodu po jego zniknięciu z naszego ekranu.

Mamy już zaimportowaną konfigurację na nasze urządzenia, teraz należy potwierdzić włączenie MFA przepisując wygenerowany kod do interfejsu Chmury Oracle i zatwierdzić wybór.

Big Data Compute Edition w Oracle Cloud - część 2

Thu, 25 Apr 2019 09:20:00 +0100

Korzystamy z burger-menu (lewy górny róg strony).

Wybieramy kolejno (tak jak na rysunku poniżej)

Burger Menu zakładka Solutions Platform and Edge My Service Dashboard

Zostaniemy przekierowani na inny interfejs graficzny podobny do tego

W lewym górnym rogu jest Burger Menu w którym kolejno wybieramy

Kolejno Services i Big Data Compute Edition.

W zakładce Instances mamy pomoc (linki do materiałów) oraz możliwość utworzenia klastra Big Data opartego o Apache Hadoop i rozwiązania Oracle.

Tworzymy klaster za pomocą Create Instance.

Konfiguracja regionu

Mamy formularz do uzupełnienia

Instance Name: hadoop1

Nazwa klastra
Nazwa z maksymalnie 50 znaków
Tylko litery i cyfry
Rozpoczynamy tylko od litery

Description: Apache Hadoop on OCI

Opis / komentarz
Przydatna przy dużej ilości usług

Notification Email: wpisujesz Swojego maila

Na ten adres przychodzą powiadomienia zmiany statusu usługi

Region: eu-frankfurt-1

Miejsce tworzenia naszej instancji

Availability Domain: sWTS:EU-FRANKFURT-1-AD-3

Rejon wraz z Availability Domain

Subnet: No Preference

Przy takim wyborze podsieć zostanie nadana automatycznie

Tags: test:true

Parametr opcjonalny
Pomaga w strukturze wielu usług

Przechodzimy do kolejnego ekranu za pomocą Next

Konfiguracja zasobów klastra

Deployment Profile: Full

Profil na jakim uruchamiamy klaster (niżej)
Full dla Spark, MapReduce, Zeppelin, Hive, Spark Thrift, Big Data File System
Basic dla Spark, MapReduce, Zeppelin
Snap dla Snap, Spark, Zeppelin

Number of Nodes: 1

Ustawiamy z ilu węzłów ma się składać klaster
Na potrzeby tego ćwiczenia ustawiamy jedną instancję (wszystkie usługi będą znajdować się na tej samej maszynie)
Dla zrobienia HA wymagana minimalna wartość to 3
Wartość maksymalna: 100

Compute Shape: VM.Standard2.2 - 2.0 OCPU, 30.0 GB RAM

Wskazuje moc zastosowanych węzłów
Dla dużych środowisk / zwiększenia wydajności dysku, sieci, CPU wybieramy wyższe parametry

Queue Profile: Preemption On

Wskazujemy kolejki zadań dla różnych typów obciążeń
Każda kolejka ma gwarantowaną minimalną wartość obciążenia
3 kolejki - Preemption On
2 kolejki - Preemption Off
Kolejki zmieniamy w panelu zarządzania

Preemption On - opis kolejek:

api (min: 50, max: 100)
interaktywna (min: 40, max: 100)
domyślna (min: 10, max: 100)

Preemption Off - opis kolejek:

dedykowana (min: 80, max: 80)
domyślna (min: 20, max: 20)

Spark Version: 2.1

Wersja platformy Apache Spark do zainstalowania
ostatnie wydanie: listopad 2016 - 1.6
ostatnie wydanie: czerwiec 2018 - 2.1

Dostęp do klastra dla użytkownika - dla nas

SSH Public Key: ssh-rsa xxxxxx...

Mamy 3 możliwości dodania dostępu do węzłów

- Key File Name wskazujemy plik z naszym kluczem publicznym
- Key Value wklejamy jego zawartość
- Create a New Key usługodawca generuje dla nas parę kluczy i otrzymujemy klucz prywatny

User Name: bdcsce_admin

Nazwa użytkownika dla konsoli Big Data Cloud i API REST
Nazwa użytkownika admin nie jest dozwolona

Password, Confirm Password: nASZe7hasło_@_fuN_GNU_tuX

Minimalnie 8 znaków
Minimum jedna mała i wielka litera
wymagana przynajmniej jedna cyfra

Konfiguracja przestrzeni do magazynowania danych

OCI Cloud Storage URL: https://objectstorage.eu-frankfurt-1.oraclecloud.com/

OCI Cloud Storage Bucket URL: oci://oraclebigdata@bigdatalinuxcom/

OCI Cloud Storage User OCID: ocid1.user.oc1..aaaaaaaafxxx ... xxx

OCI Cloud Storage PEM Private Key: plik oci_api_key.pem

OCI Cloud Storage PEM Key Fingerprint: 36:76:14:2a:5b:65:02:d5:98:d4:b5:8b:df:d6:d0:e0

Konfiguracja wydajności powierzchni magazynowania

Use High Performance Storage: [ ]

Zwiększa wydajność Hadoop Distributed File System (HDFS)

Usable HDFS Storage (GB): 50

Przestrzeń dla przechowywania danych
Przy domyślnej replikacji 2 razy większa
5% zarezerwowane na logi
Maksymalna powierzchnia to 438 TB

Usable BDFS Cache (GB): 50

Maksymalnie to 74 TB

Powiązania między usługami

Łączymy usługi tak, aby mogły się ze sobą komunikować

Podsumowanie

Po prawej stronie mamy możliwość pobrania pliku xml z wybraną konfiguracją.

Big Data Compute Edition w Oracle Cloud - część 1

Thu, 25 Apr 2019 09:10:00 +0100

Przed uruchomieniem klastra należy utworzyć przestrzeń w której będziemy trzymać nasze dane. Do tego posłuży nam koszyczek bucket (nazewnictwo i funkcjonalność tej usługi podobna do AWS).

Korzystamy z burger-menu (lewy górny róg strony).

Wybieramy kolejno (tak jak na rysunku poniżej):

Burger Menu, zakładka Core Infrastructure, Object Storage, w menu rozwijanym Object Storage

Należy wybrać gdzie będziemy tworzyć nasz koszyk. Wyboru dokonujemy w menu po lewej stronie w zakładce List Scope.

Po wybraniu wyświetli nam się aktywny klawisz za pomocą którego utworzymy koszyk na dane. Wybieramy Create Bucket

Pojawi się okienko z kilkoma polami do uzupełnienia. Najważniejsze z nich, które należy skonfigurować:

nazwa koszyczka: oraclebigdata
typ koszyka: standard
tagi: prod false

Typ koszyka definiuje nam z jakiego typu powierzchni do przechowywania danych możemy skorzystać. Główną różnicą jest wydajność. Ogólnie dokonany wybór wpływa również na koszt.

Tagi są bardzo pomocne przy katalogowaniu zasobów, ich rozliczeniu, zwiększają czytelność i możliwość zarządzania.

Po uzupełnieniu pól należy zatwierdzić za pomocą Create Burger.

Na liście pojawi nam się nowo utworzony koszyczek. Wybierając go (klikając na jego nazwę lub z bocznego menu: . . . View Bucket) mamy dostępne jego szczegóły. Dla nas najważniejszy jest adres przydziału. Wyświetlamy go wybierając Show z wiersza z opisem Compartment.

Ten adres należy sobie zapisać, gdyż będzie nam potrzebny przy uruchamianiu klastra.

Mamy już adres składowania danych, potrzebujemy jeszcze użytkownika, który będzie zarządzał klastrem. Dla naszego przykładu posłużymy się naszą tożsamością. Wybieramy ikonkę profilu w prawym górnym rogu naszego web-interfejsu. Oznaczono zielonym kółeczkiem.

Z menu wybieramy opcję oracleidentitycloudservice/marcin@gnulinux.pl.

Podobnie jak przy adresie wiaderka i ten adres musimy sobie zachować.

Dla umożliwienia zestawienia połączenia ze środowiskiem (dostęp użytkownik do zarządzania wiaderkiem poprzez API) należy dodać nasz klucz publiczny.

Najlepiej wygenerować parę kluczy na Swoim komputerze. Jak to zrobić? Na swoim komputerze tworzymy katalog .oci w katalogu domowym.

mkdir ~/.oci

Wyniki niektórych poleceń mogą się nieznacznie różnić od Twoich

Generujemy nasz klucz prywatny:

openssl genrsa -out ~/.oci/oci_api_key.pem 2048

W terminalu otrzymamy:

Generating RSA private key, 2048 bit long modulus (2 primes)
.........................................................+++++
................................................................+++++
e is 65537 (0x010001)

Ważne jest, aby utworzyć klucz bez hasła

Zmieniamy uprawnienia (tylko do odczytu)

chmod go-rwx ~/.oci/oci_api_key.pem

Odczytujemy fingerprint naszego kucza prywatnego:

openssl rsa -pubout -outform DER -in ~/.oci/oci_api_key.pem | openssl md5 -c

Poglądowy wynik polecenia:

writing RSA key
(stdin)= 59:67:f7:c1:26:18:9f:f2:a6:f9:56:dd:66:85:b8:96

Tworzymy klucz publiczny:

openssl rsa -pubout -in ~/.oci/oci_api_key.pem -out ~/.oci/oci_api_key_public.pem

Wynik polecenia:

writing RSA key

Sprawdzamy czy wszystko jest np. poleceniem ls lub tree

tree ~/.oci

Oczekiwany wynik:

/home/marcin/.oci
├── oci_api_key.pem
└── oci_api_key_public.pem

0 directories, 2 files

Sprawdzamy zawartość naszego klucza publicznego:

cat ~/.oci/oci_api_key_public.pem

Oczekiwany wynik:

Kopiujemy powyższy wynik polecenia cat do naszego interfejsu. Wybieramy Add Public Key i w pole Public Key wklejamy całość.

Zatwierdzamy klawiszem Add.

Oczekiwany wynik przedstawia poniższy rysunek. Fingerprint klucza powinien być identyczny z wynikiem naszego polecenia, u mnie to 59:67:f7:c1:26:18:9f:f2:a6:f9:56:dd:66:85:b8:96.

Rozpoczęcie pracy w chmurze Oracle Cloud

Wed, 24 Apr 2019 00:00:00 +0000

Tworzymy konto

Przechodzimy na stronę https://myservices.us.oraclecloud.com/mycloud/signup i korzystamy z promocji Get zł1150 of free credits good for up to 3500 hours of Oracle Cloud usage for the next 30 days. Rejestracja jest łatwa. Podajemy nasz adres e-mail i nasz kraj.

Na kolejnej stronie wybieramy typ naszego konta: do użytku prywatnego Account Type: Personal Use

W kolejnym polu wskazujemy nazwę naszego projektu, użyj innej nazwy niż na obrazku.

Wybór regionu jest zawężony do dwóch, w których działa bezpłatna usługa Free Oracle Cloud Promotion:

Ameryka Północna North America
Obszar Europy, Bliskiego Wschodu i Afryki EMEA

Dobrym wyborem jest EMEA

Po uzupełnieniu wymaganych danych (oznaczonych gwiazdką) oczekujemy SMSa z kodem weryfikacyjnym (numer składający się z 7 cyfr). Wiadomość przychodzi po ok. 20 sekundach, mamy 2 minuty na przepisanie numeru - gdy czas upłynie, możemy ponowić przesłanie numeru wybierając Resend Code. W moim przypadku nadawcą wiadomości był 22 884.

Kolejnym krokiem jest dodanie karty płatniczej.

Po przepisaniu i akceptacji danych (trwa to 10 sekund) zostajemy przeniesieni na https://cloud.oracle.com/getting-started i już możemy się zalogować.

Logowanie

Na stronie https://cloud.oracle.com/home podajemy trzy dane do logowania:

nazwa projektu
login
hasło

Tymczasowe hasło otrzymamy mailem (oczekiwałem mniej niż minutę).

Nazwa projektu to ten sam wpis, który utworzyliśmy podczas rejestrowania się w Oracle Cloud.

Na kolejnym ekranie podajemy nasz e-mail i hasło tymczasowe.

Ustalamy nasze nowe hasło.

Należy zwrócić uwagę na wymagania:

minimum 12 znaków
lecz nie więcej niż 40
nie może zawierać imienia
nie może zawierać nazwiska
nie może zawierać nazwy użytkownika
musi posiadać przynajmniej jeden mały znak
musi posiadać przynajmniej jedną dużą literę
musi posiadać przynajmniej jedną cyfrę
nie mogą powtarzać się 4 znaki

Po poprawnym zatwierdzeniu hasła zostaniemy przekierowani na panel Dashboard. Po prawej stronie WebUI powinniśmy zobaczyć nasz billing.

Pozostaje tylko ustawić nasze preferencje dot.

wybór języka interfejsu
wybór kraju
wybór strefy czasowej

Zakładanie konta zakończone :)

Instalacja dystrybucji Hortonworks Data Platform 3.1 za pomocą Apache Ambari

Thu, 18 Apr 2019 00:00:00 +0000

Instrukcja instalacji dystrybucji Hortonworks Data Platform HDP 3.1 na maszynach z systemem Red Hat 7 lub CentOS 7.

Do instalacji zostanie użyte:

HDP-3.1.0.0
Apache Ambari w wersji 2.7.3.0
CentOS 7 lub Red Hat 7

Instalacja może być przeprowadzona tylko na jednej maszynie oraz w klastrze. W przypadku jednej maszyny należy w każdym miejscu konfiguracji wskazać jeden i ten sam host. Wszystko usługi, zarówno typu master jak i slave, będą zainstalowane na tym jednym komputerze.

W przypadku systemów produkcyjnych jedyną zalecaną opcją jest instalacja w klastrze kilku maszyn. Jedną maszynę możemy wykorzystywać do celów testowych i developerskich.

Przygotowanie maszyn

Taką instalację możemy przeprowadzić w dowolnym środowisku, np. z użyciem VirtualBoxa lub chmury AWS

Klaster ssh

Jeśli chcemy wykonywać wybrane polecenia jednocześnie na wszystkich maszynach możemy użyć polecenia cssh.

cssh root@hdp1 root@hdp2 root@hdp3

Jeśli wolimy klasyczne ssh, logujemy się na każdą maszynę oddzielnie:

ssh root@hdp1

UWAGA: Wszystkie dalsze polecenia wykonujemy zalogowani jako użytkownik root

Dostęp do internetu

Żeby instalować dodatkowe pakiety musimy mieć dostęp do internetu. Jeśli nie jest on dostępny, można spróbować włączyć DHCP.

Aby włączyć ręcznie DHCP należy wykonać:

dhclient -v

W celu skonfigurowania tego na stałe warto zmienić wartość (ONBOOT=yes) w pliku /etc/sysconfig/network-scripts/ifcfg-eth0

yum install -y vim
vim /etc/sysconfig/network-scripts/ifcfg-enp0s3

Włączamy logowanie root’a po haśle

Jeśli chcemy umożliwić logowanie użytkownika root po haśle ustawiamy parametr (PermitRootLogin yes) w pliku /etc/ssh/sshd_config

vim /etc/ssh/sshd_config

(UWAGA nigdy tego nie róbmy na produkcyjnych serwerach, NIGDY!)

Logowanie po SSH

Jeśli korzystamy z systemów Linux/Mac wygodnym rozwiązaniem może okazać się konfiguracja dostępu z swojego komputer i swojej konsoli. Żeby nie musieć podawać przy logowaniu ciągle hasła, warto wrzucić na maszynę wirtualną swój klucz publiczny by logować się bez hasła.

ssh-copy-id root@localhost -p 2222
ssh root@localhost -p 2222

Możliwość logowania do wszystkich maszyn możemy sprawdzić za pomocą polecenia:

for i in {1..5..1}; do ssh hdp${i} uptime; done

Aktualizacja systemu

Żeby pracować na najnowszej wersji systemu należy go zaktualizować

yum -y update
yum -y upgrade

Instalacja epel release

CentOS:

yum install -y epel-release

Red Hat:

cd /tmp
yum install -y wget
wget https://dl.fedoraproject.org/pub/epel/epel-release-latest-7.noarch.rpm
yum install -y epel-release-latest-7.noarch.rpm
yum repolist

Instalacja kolejnych przydatnych narzędzi

yum -y install wget vim htop ntp openssh-server openssh-clients nano bash-completion tree mc byobu ncdu

Zmieniamy hostname (opcjonalnie)

Uwaga, ustawiamy nowe wpisy hostname tylko i wyłącznie wtedy gdy chcemy je zmienić na własne. W wielu przypadkach możemy zostawić obecne hosty o ile są jakieś dostępne.

Na każdej z maszyn ustawiamy inny hostname, na przykład:

hostnamectl set-hostname hdpx.bigdatapassion.com
hostnamectl set-hostname "Hortonworks Data Platform Node" --pretty
hostnamectl set-hostname hdpx.bigdatapassion.com --static
hostnamectl set-hostname hdpx.bigdatapassion.com --transient

gdzie x to numer danego węzła, czyli hdp1, hdp2 i tak dalej.

Jeśli mamy jedną maszynę możemy ustawić:

hostnamectl set-hostname sandbox.bigdatapassion.com

Status możemy sprawdzić

hostnamectl status
hostname
hostname -f

Polecenie hostname i hostname -f powinny zwracać tą samą wartość.

Konfiguracja hostów

Poniższe ustawienie jest nam niezbędne jeśli ustawiliśmy własne wpisy hostname (punkt wyżej) oraz nie mamy żadnego systemu DNS który mógłby informować nasze maszyny jaki hostname odpowiada jakiemu adresowi ip.

Żeby maszyny się “widziały” musimy każdej ustawić odpowiedni hostname:

192.168.172.201 hdp1.bigdatapassion.com
192.168.172.202 hdp2.bigdatapassion.com
192.168.172.203 hdp3.bigdatapassion.com

Dla maszyn które mają zarówno adresy prywatne jak i publiczne (np. AWS lub Oracle Cloud) powinniśmy ustawić te prywatne. Oczywiście lista zależy od liczby maszyn (w tym przypadku 3) oraz adresach ip które można sprawdzić za pomocą polecenia “ip a”.

Dla jednego serwera możemy użyć localhost/127.0.0.1:

127.0.0.1   sandbox sandbox.bigdatapassion.com
127.0.0.1   localhost localhost.localdomain localhost4 localhost4.localdomain4
::1         localhost localhost.localdomain localhost6 localhost6.localdomain6

Konfigurujemy logowanie SSH bez hasła

Na każdej maszynie generujemy zestaw kluczy:

ssh-keygen -f .ssh/id_rsa -t rsa -N ''

Na maszynie hdp1 wyświetlamy sobie klucz publiczny:

cat .ssh/id_rsa.pub

Pobrany klucz maszyny hdp1 wklejamy na każdej maszynie (także hdp1) do pliku:

vim .ssh/authorized_keys

Jeśli wszystko poszło jak trzeba z maszyny hdp1 możemy teraz zalogować się po SSH do każdej innej maszyny:

ssh hdp3.bigdatapassion.com

Jeśli instalujemy to na jednej maszynie wystarczy wykonać:

ssh-keygen -f .ssh/id_rsa -t rsa -N ''
ssh-copy-id sandbox.bigdatapassion.com
ssh sandbox.bigdatapassion.com

Wyłączamy selinux

Edytujemy plik /etc/sysconfig/selinux ustawiając SELINUX na disabled.

sed -i 's/SELINUX=enforcing/SELINUX=disabled/g' /etc/sysconfig/selinux
sed -i 's/SELINUX=enforcing/SELINUX=disabled/g' /etc/selinux/config
setenforce 0
sestatus

Wyłączamy Firewall’a

systemctl disable firewalld
systemctl stop firewalld
systemctl status firewalld
systemctl disable firewalld.service
systemctl stop firewalld.service
systemctl status firewalld.service

Włączamy serwer czasu NTP

yum install -y ntp
systemctl disable chrony.service
systemctl enable ntpd
systemctl start ntpd
systemctl status ntpd
systemctl enable ntpd.service
systemctl is-enabled ntpd.service
systemctl start ntpd.service
systemctl status ntpd.service

Umask

umask 022
echo umask 022 >> ~/.bash_profile
echo umask 022 >> /etc/profile

Restart maszyn

Teraz warto wykonać restart wszystkich maszyn poleceniem reboot

Instalacja Apache Ambari

UWAGA: Od teraz wszystkie operacje wykonujemy tylko na maszynie hdp1

wget -nv http://public-repo-1.hortonworks.com/ambari/centos7/2.x/updates/2.7.3.0/ambari.repo -O /etc/yum.repos.d/ambari.repo

yum repolist
yum update

Instalujemy Ambari

yum install ambari-server -y

Konfigurujemy Ambari

(W każdym pytaniu wybieramy odpowiedź domyślną klikając klawisz Enter za każdrym razem)

ambari-server setup

W przypadku ambari-server setup upewniamy się, że nie ma żadnych ostrzeżeń, zaś na wszystkie pytania odpowiadamy wartościami domyślnymi klikając enter:

[root@hdp1 ~]# ambari-server setup
Using python  /usr/bin/python
Setup ambari-server
Checking SELinux...
SELinux status is 'enabled'
SELinux mode is 'permissive'
WARNING: SELinux is set to 'permissive' mode and temporarily disabled.
OK to continue [y/n] (y)? y
Customize user account for ambari-server daemon [y/n] (n)? 
Adjusting ambari-server permissions and ownership...
Checking firewall status...
Checking JDK...
[1] Oracle JDK 1.8 + Java Cryptography Extension (JCE) Policy Files 8
[2] Custom JDK
==============================================================================
Enter choice (1): 1
To download the Oracle JDK and the Java Cryptography Extension (JCE) Policy Files you must accept the license terms found at http://www.oracle.com/technetwork/java/javase/terms/license/index.html and not accepting will cancel the Ambari Server setup and you must install the JDK and JCE files manually.
Do you accept the Oracle Binary Code License Agreement [y/n] (y)? y
Downloading JDK from http://public-repo-1.hortonworks.com/ARTIFACTS/jdk-8u112-linux-x64.tar.gz to /var/lib/ambari-server/resources/jdk-8u112-linux-x64.tar.gz
jdk-8u112-linux-x64.tar.gz... 100% (174.7 MB of 174.7 MB)
Successfully downloaded JDK distribution to /var/lib/ambari-server/resources/jdk-8u112-linux-x64.tar.gz
Installing JDK to /usr/jdk64/
Successfully installed JDK to /usr/jdk64/
Downloading JCE Policy archive from http://public-repo-1.hortonworks.com/ARTIFACTS/jce_policy-8.zip to /var/lib/ambari-server/resources/jce_policy-8.zip

Successfully downloaded JCE Policy archive to /var/lib/ambari-server/resources/jce_policy-8.zip
Installing JCE policy...
Check JDK version for Ambari Server...
JDK version found: 8
Minimum JDK version is 8 for Ambari. Skipping to setup different JDK for Ambari Server.
Checking GPL software agreement...
GPL License for LZO: https://www.gnu.org/licenses/old-licenses/gpl-2.0.en.html
Enable Ambari Server to download and install GPL Licensed LZO packages [y/n] (n)? y
Completing setup...
Configuring database...
Enter advanced database configuration [y/n] (n)? n
Configuring database...
Default properties detected. Using built-in database.
Configuring ambari database...
Checking PostgreSQL...
Running initdb: This may take up to a minute.
Initializing database ... OK


About to start PostgreSQL
Configuring local database...
Configuring PostgreSQL...
Restarting PostgreSQL
Creating schema and user...
done.
Creating tables...
done.
Extracting system views...
ambari-admin-2.7.3.0.139.jar
....
Ambari repo file contains latest json url http://public-repo-1.hortonworks.com/HDP/hdp_urlinfo.json, updating stacks repoinfos with it...
Adjusting ambari-server permissions and ownership...
Ambari Server 'setup' completed successfully.

Uruchamiamy Ambari

ambari-server start

Instalacja sterownika JDBC

Jeśli w naszym klastrze chcielibyśmy użyć narzędzia Apache Hive lub innego który używa biblioteki jdbc, konieczne będzie ściągnięcie i zarejestrowanie odpowiedniego sterownika jdbc za pomocą poniższego polecenia:

wget http://central.maven.org/maven2/mysql/mysql-connector-java/8.0.12/mysql-connector-java-8.0.12.jar
mv mysql-connector-java-8.0.12.jar /opt/
ll /opt/ | grep mysql
ambari-server setup --jdbc-db=mysql --jdbc-driver=/opt/mysql-connector-java-8.0.12.jar

Powyższy przykład dotyczy bazy MySQL, dla innej oczywiście potrzebny jest analogiczny sterownik.

Konfiguracja klastra HDP za pomocą Ambari UI

Następnie wchodzimy na adres: http://hdp1:8080 (lub inny wybrany hostname) i całą instalację kontynuujemy w trybie graficznym. Logujemy się jako admin / admin.

Następnie klikamy przycisk Launch Install Wizard

Ustawiamy nazwę naszego klastra

Wybieramy wersję dystrybucji którą chcemy zainstalować

W kolejnym ekranie w polu Target Hosts wskazujemy pełne adresy wybranych maszyn na których chcemy postawić dystrybucję

hdp1.bigdatapassion.com
hdp2.bigdatapassion.com
hdp3.bigdatapassion.com

lub dla jednej maszyny:

sandbox.bigdatapassion.com

oraz wklejamy zawartość pliku /root/.ssh/id_rsa maszyny na której zainstalowaliśmy Ambari

Po kliknięciu Register and Confirm Ambari przygotowuje nasze maszyny do instalacji

Po zakończonym procesie powinniśmy dostać informację o udanym przygotowaniu maszyn

Jeśli jednak mamy informację o ostrzeżeniach na końcu instalacji agentów lub błędach podczas instalacji, należy przejrzeć ich listę i rozwiązać problemy

Następnie wybieramy narzędzia które chcemy zainstalować (ilość i rodzaj według uznania, np. HDFS, MapReduce2, Tez, Hive, Pig, HBase, Oozie, Flume, Ambari Metrics)

Niektóre narzędzia są połączone na tyle silnie, że Ambari może nam zasugerować konieczność instalacji czegoś dodatkowo

Ambari będzie także proponować nam instalację narzędzi które twórcy uznali za ważne a my ich samodzielnie nie wybraliśmy

Wskazujemy na których maszynach mają być zainstalowane usługi zarządzające (Masters) (można zostawić na początek proponowane rozmieszczenie, tematowi jak rozmieszczać usługi przyjrzymy się w innym wpisie)

oraz usługi robocze (Slaves) (dla naszego testowego środowiska wybieramy wszystkie maszyny dla każdej z usług)

Konfigurujemy nasze serwisy, pola wymagane są na czerwono (najczęściej konieczność ustawienia hasła do bazy danych), pozostałe ustawienia na ten moment możemy pozostawić w ich wartościach domyślnych

Akceptujemy ostrzeżenia i dostajemy podsumowanie instalacji

Na koniec Ambari zaczyna instalować wszystkie usługi zgodnie z naszymi wytycznymi

Po zakończonej instalacji możemy korzystać już w pełni wdrożonego klastra.

Możliwe problemy

Gdyby w trakcie instalacji wystąpiły jakieś błędy podczas uruchamiania usług, możemy spróbować zatrzymać wszystkie serwisy a następnie ponownie je włączyć. W tym celu w lewym pasku serwisów w menu Actions wybieramy Stop All a następnie Start All.

W przypadku niektórych wersji systemu CentOS lub Red Hat konieczna może okazać się ta porada związana z brakiem biblioteki libtirpc-devel.

Legenda

AI & NLP WORKSHOP DAY 2018

Tue, 09 Oct 2018 00:00:00 +0000

19 października 2018 roku będę prowadził dwa warsztaty w ramach wydarzenia AI & NLP Workshop Day.

Obydwa warsztaty będą dotyczyć bardzo popularnych obecnie tematów w Big Data i AI jakimi są przetwarzanie strumieniowe w czasie rzeczywistym oraz wykorzystaniu chmur publicznych.

Dla osób chcących wziąć udział w tym wydarzeniu przekazuje kod zniżkowy (15%) dbUFYw :)

Building Realtime & Big Data Pipelines with Apache Kafka

Mon, 08 Oct 2018 00:00:00 +0000

Na kanale YouTube Confitury pojawiły się nagrania z tegorocznej konferencji.

Poniżej relacja:

oraz moja prezentacja:

Podcast na temat Big Data

Fri, 20 Jul 2018 00:00:00 +0000

Na stronie Stacji IT pojawił się nowy podcast w ramach którego miałem przyjemność opowiedzieć o Big Data.

Można go odsłuchać na stronie: https://stacja.it/podcast/2018-07-20-radek-szmit-o-big-data.html

Polecam także inne podcasty, można się dowiedzieć więcej o Big Data, Data Science, programowaniu i wielu innych ciekawych tematach.

Konferencje o tematyce Big Data

Thu, 19 Jul 2018 00:00:00 +0000

Poniżej na bieżąco zbierana i aktualizowana lista najciekawszych konferencji o tematyce Big Data w Polsce i za granicą.

Lista alfabetyczna!

Polskie konferencje

AI & NLP Workshop Day - October 19th, 2018, Warsaw, Poland
ADFORM HIGH LOAD STRATEGY CONFERENCE 2018 - 4 October, Copernicus Science Center, Wybrzeże Kościuszkowskie 20, Warsaw, Poland
Big Data Tech Warsaw - Warsaw, Poland, on February 2019
Confitura - 30 June 2018
Data Workshop Club Conf - 13 października, Warszawa
Devoxx - Krakow, Poland, 24-27 June 2019
Machine Learning@Enterprise - 18 września 2018
Polish View on Machine Learning - Warsaw, 14 - 17.12.2018
PyData Warsaw - 19-20 November 2018
Scalar - 6-7.04.2018
WhyR

Zagraczniczne konferencje

Data Science Conference / 4.0 - 18 i 19 września w Belgradzie
DATAWORKS SUMMITS
SPARK + AI SUMMIT

Apache Kafka w kontenerze Docker

Fri, 22 Jun 2018 00:00:00 +0000

Apache Kafka można z łatwością uruchomić na swoim komputerze korzystając z gotowych obrazów Dockera. Poniżej kilka przykładów jak to zrobić.

Użyjemy obrazów:

Jeden broker i ZooKeeper

Przygotowanie sieci:

docker network rm bdp_kafka_network
docker network create --driver bridge bdp_kafka_network
docker network ls

Kontener ZooKeepera:

docker run --name zookeeper.bigdatapassion.pl \
    -p 2181:2181 \
    --network=bdp_kafka_network \
    --hostname=zookeeper.bigdatapassion.pl \
    -d \
    wurstmeister/zookeeper:latest

Kontener Kafki:

docker run --name kafka.bigdatapassion.pl \
    -p 9092:9092 \
    --env KAFKA_ZOOKEEPER_CONNECT=zookeeper.bigdatapassion.pl \
    --network=bdp_kafka_network \
    --hostname=kafka.bigdatapassion.pl \
    -d \
    wurstmeister/kafka:1.0.1

Dodajemy w pliku /etc/hosts:

127.0.0.1   zookeeper.bigdatapassion.pl kafka.bigdatapassion.pl

Żeby zatrzymać i wyczyścić:

docker stop zookeeper.bigdatapassion.pl
docker stop kafka.bigdatapassion.pl

docker rm zookeeper.bigdatapassion.pl
docker rm kafka.bigdatapassion.pl

docker ps -a

Trzech brokerów i ZooKeeper

Jeśli chcemy uruchomić lokalnie Apache Kafka na więcej niż jednym brokerze za pomocą Dockera może użyć do tego Docker Compose

Kafka 1.0.0

version: '3.5'

services:

  zookeeper:
      container_name: cluster_zookeeper
      image: wurstmeister/zookeeper
      ports:
        - "2181:2181"
      networks:
        - kafkanetwork

  kafka1:
      container_name: cluster_kafka1
      image: wurstmeister/kafka:1.0.0
      ports:
        - "9092:9092"
      hostname: cluster_kafka1
      networks:
        - kafkanetwork
      environment:
        KAFKA_ADVERTISED_LISTENERS: cluster_kafka1
        KAFKA_ZOOKEEPER_CONNECT: cluster_zookeeper:2181
      depends_on:
        - zookeeper

  kafka2:
      container_name: cluster_kafka2
      image: wurstmeister/kafka:1.0.0
      ports:
        - "9093:9092"
      hostname: cluster_kafka2
      networks:
        - kafkanetwork
      environment:
        KAFKA_ADVERTISED_LISTENERS: cluster_kafka2
        KAFKA_ZOOKEEPER_CONNECT: cluster_zookeeper:2181
      depends_on:
        - kafka1
  kafka3:
      container_name: cluster_kafka3
      image: wurstmeister/kafka:1.0.0
      ports:
        - "9094:9092"
      hostname: cluster_kafka3
      networks:
        - kafkanetwork
      environment:
        KAFKA_ADVERTISED_LISTENERS: cluster_kafka3
        KAFKA_ZOOKEEPER_CONNECT: cluster_zookeeper:2181
      depends_on:
        - kafka2

networks:
  kafkanetwork:
    driver: bridge

Kafka 1.1.0

version: '3.5'

services:

  zookeeper:
      container_name: cluster_zookeeper
      image: wurstmeister/zookeeper
      ports:
        - "2181:2181"
      networks:
        - kafkanetwork

  kafka1:
      container_name: cluster_kafka1
      image: wurstmeister/kafka:1.1.0
      ports:
        - "9092:9092"
      hostname: cluster_kafka1
      networks:
        - kafkanetwork
      environment:
        KAFKA_LISTENERS: PLAINTEXT://:9092
        KAFKA_ZOOKEEPER_CONNECT: cluster_zookeeper:2181
      depends_on:
        - zookeeper

  kafka2:
      container_name: cluster_kafka2
      image: wurstmeister/kafka:1.1.0
      ports:
        - "9093:9092"
      hostname: cluster_kafka2
      networks:
        - kafkanetwork
      environment:
        KAFKA_LISTENERS: PLAINTEXT://:9092
        KAFKA_ZOOKEEPER_CONNECT: cluster_zookeeper:2181
      depends_on:
        - kafka1
  kafka3:
      container_name: cluster_kafka3
      image: wurstmeister/kafka:1.1.0
      ports:
        - "9094:9092"
      hostname: cluster_kafka3
      networks:
        - kafkanetwork
      environment:
        KAFKA_LISTENERS: PLAINTEXT://:9092
        KAFKA_ZOOKEEPER_CONNECT: cluster_zookeeper:2181
      depends_on:
        - kafka2

networks:
  kafkanetwork:
    driver: bridge

Instalacja Apache Kafka

Wed, 20 Jun 2018 00:00:00 +0000

W dzisiejszym poście jak zainstalować sobie szybko kafkę lokalnie do testów. Będziemy używać dystrybucji Apache.

Instalacja dla systemu Linux.

Instalacja wersji z jednym brokerem

Zaczynamy od ściągnięcia Kafki i rozpakowania w nowym katalogu. Najnowsza wersja jest do ściągnięcia ze strony projektu. Będziemy używać wersji Kafki 1.1.0 dla języka Scala w wersji 2.11 (aktualnie 2.11 jest zalecana zarówno dla Kafki jak i Sparka stąd dość oczywisty wybór).

mkdir kafka
cd kafka
wget http://ftp.man.poznan.pl/apache/kafka/1.1.0/kafka_2.11-1.1.0.tgz
tar -xzf kafka_2.11-1.1.0.tgz

Uruchomienie jednego brokera

Jeśli chcemy pracować w wersji z jednym brokerem to już koniec. Teraz wystarczy uruchomić Zookeepera

cd kafka_2.11-1.1.0/
bin/zookeeper-server-start.sh config/zookeeper.properties

oraz brokera

bin/kafka-server-start.sh config/server.properties

Oczywiście robimy to w oddzielnych terminalach lub w tle jako demony (pokazane niżej).

Operacje na Apache Kafka

Zaczynamy od stworzenia topicu

bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic test

teraz możemy sprawdzić listę topiców

bin/kafka-topics.sh --list --zookeeper localhost:2181

Uruchamiamy skrypt producenta

bin/kafka-console-producer.sh --broker-list localhost:9092 --topic test

oraz skrypt konsumenta

bin/kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic test --from-beginning

i wysyłamy kilka wiadomości z poziomu producenta sprawdzając czy zostały odebrane przez konsumenta. Jeśli zobaczymy nasze wiadomości, Kafka działa poprawnie.

Kilku brokerów

By poczuć się jak w środowisku rozproszonym, powołamy do życia dwóch kolejnych brokerów na tym samym komputerze

cp config/server.properties config/server1.properties
cp config/server.properties config/server2.properties

vim config/server1.properties
vim config/server2.properties

Edytując dwa ostatnie pliki zmieniamy

broker.id=0
listeners=PLAINTEXT://:9092
log.dirs=/tmp/kafka-logs

broker.id=1
listeners=PLAINTEXT://:9093
log.dirs=/tmp/kafka-logs1

oraz

broker.id=2
listeners=PLAINTEXT://:9094
log.dirs=/tmp/kafka-logs2

(uwaga opcja listeners może być zakomentowana, trzeba usunąć znak # przed nazwą)

Następnie uruchamiamy dwóch dodatkowych brokerów w oddzielnych oknach terminala (poprzedni jest ciągle włączony)

bin/kafka-server-start.sh config/server1.properties
bin/kafka-server-start.sh config/server2.properties

Tworzymy zreplikowany topic

bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 3 --partitions 1 --topic my-replicated-topic

oraz topic z partycjami

bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 3 --topic my-partitioned-topic

oraz topic zreplikowany z partycjami

bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 3 --partitions 3 --topic my-super-topic

wyświetlamy listę topiców

bin/kafka-topics.sh --list --zookeeper localhost:2181

wyświetlamy informacje o topicach za pomocą describe

bin/kafka-topics.sh --describe --zookeeper localhost:2181 --topic test
bin/kafka-topics.sh --describe --zookeeper localhost:2181 --topic my-replicated-topic
bin/kafka-topics.sh --describe --zookeeper localhost:2181 --topic my-partitioned-topic
bin/kafka-topics.sh --describe --zookeeper localhost:2181 --topic my-super-topic

Docker - najbardziej przydatne polecenia

Mon, 18 Jun 2018 00:00:00 +0000

Docker jest obecnie jednym z najpopularniejszych systemów konteneryzacji. O kontenerze możemy myśleć jak o czymś pomiędzy maszyną wirtualną która jest w pełni odizolowanym środowiskiem a aplikacjami instalowanymi w jednym wspólnym serwerze. Poniżej lista najbardziej przydatnych poleceń Docker’a.

Info

docker info
docker --version

Obrazy

docker images
docker rmi centos
docker rmi `docker images -q`
docker rmi -f `docker images -q`

Kontenery

docker ps
docker ps -a

Usunięcie kontenerów

docker rm `docker ps -aq`
docker rm -f `docker ps -aq`

Podgląd

docker inspect centos

Uruchomienie

docker run [--name=NAZWA] OBRAZ [POLECENIE]
docker run centos echo "Witaj świeci"

Logi

docker logs [nazwa]

Bash

docker exec -it NAZWA_URUCHOMIONEGO_KONTENERA bash

Networking

docker network rm `docker network ls -q`

Kopiowanie plików

docker cp kataloglokalny/plik.txt container:/tmp

Docker Compose

docker-compose up
docker-compose down

Big Data i sztuczna inteligencja na konferencji Confitura 2018

Tue, 05 Jun 2018 00:00:00 +0000

W tym roku, jedna z największych i moim zdaniem zarazem najlepszych polskich konferencji, czyli Confitura, po raz pierwszy będzie miała specjalną oddzielną ścieżkę Big Data and Artificial Intelligence.

Ścieżka Big Data and Artificial Intelligence pojawia się na niej po raz pierwszy, jednak z racji dużej popularności platformy Java w Big Data i Data Science, pojawiały się tam już wcześniej tematy o podobnej tematyce. Chyba nie muszę przypominać, że takie narzędzia jak choćby Hadoop, Hive, Spark, Kafka czy Zeppelin, są stworzone właśnie w języku Java i/lub Scala.

Także po raz pierwszy w tym roku, konferencji będą towarzyszyć warsztaty następnego dnia po konferencji.

Jeśli chcielibyście zobaczyć jak było na poprzednich edycjach, polecam kanał konferencji na YouTube.

Zapraszam także przy okazji na moją prezentację oraz warsztaty dotyczące jednej z obecnie najpopularniejszych technologii Big Data, czyli Apache Kafka.

Wyzwanie Java #7: Programowanie funkcyjne - rozwiązanie

Fri, 01 Jun 2018 00:00:00 +0000

Czas na rozwiązanie ostatniego wyzwania z programowania w języku Java. Tym razem chcieliśmy byście użyli funkcjonalności dostępnych od JDK w wersji 8 to przetworzenia zbioru filmów z portalu MovieLens (zbiór MovieLens 20M Dataset, plik movies.csv).

Programowanie funkcyjne dla wielu początkujących osób bywa bardzo trudne oraz wymaga praktyki, dlatego pozostawiliśmy tą część języka Java na sam koniec. Gdybyście chcieli rozszerzyć wiedzę z tego zakresu, oprócz dokumentacji i materiałów dostępnych w internecie, na rynku można znaleźć wiele książek dotyczących programowania funkcyjnego w Javie 8, jak choćby Functional Programming in Java której autorem jest Venkat Subramaniam, bardzo popularny prezenter na konferencjach programistycznych w Polsce i na świecie lub Java 8. Przewodnik doświadczonego programisty Cay S. Horstmanna, autora wielu cenionych książek do nauki języka Java.

Poniżej możliwe rozwiązanie naszego ostatniego wyzwania:

package pl.kodolamacz.func;

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.IntSummaryStatistics;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

import static java.text.MessageFormat.format;

public class Challenge7 {

    public static void main(String[] args) {

        Path sourcePath = Paths.get("/tmp/ml-20m/movies.csv");

        List<String> lines;
        try {
            lines = Files.readAllLines(sourcePath);
        } catch (Exception e) {
            System.out.println("Błąd dostępu do pliku: " + sourcePath.getFileName());
            return;
        }

        // Parsowanie pliku CSV
        List<String[]> movies = lines.stream()
                .skip(1) // pomijamy nagłówek
                .map(Challenge7::parseCSV)
                .collect(Collectors.toList());

        // Łączną ilość filmów w pliku (celowo użycie strumieni a nie lines.count)
        long count = movies.stream().count();

        System.out.println(format("Łączna ilość filmów w pliku: {0}", count));

        // Przedział lat w jakim te filmy wyszły (daty są w nawiasie w tytule)
        IntSummaryStatistics statistics = movies.stream()
                .map(movie -> movie[1].trim())
                // rok filmu jest zawsze na końcu
                .map(title -> title.substring(title.length() - 5, title.length() - 1))
                .filter(Challenge7::isNumeric)
                .mapToInt(Integer::parseInt)
                .summaryStatistics();

        System.out.println(format("Filmy zostały wyprodukowane w latach {0} - {1}", statistics.getMin(), statistics.getMax()));

        // Ile filmów znajduje się w każdym gatunku filmowym
        Map<String, Long> genresCollect = movies.stream()
                .map(movie -> movie[2])
                // Znak | jest wyrażeniem specjalnym, musimy użyć \\ by potraktować go jak zwykły znak
                .flatMap(genres -> Arrays.stream(genres.split("\\|")))
                .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));

        genresCollect.entrySet().stream()
                .sorted(Map.Entry.comparingByKey())
                .forEach(entry -> System.out.println("Gatunek: " + entry.getKey() + " ilość filmów: " + entry.getValue()));

        // Najczęstszy gatunek filmowy
        genresCollect.entrySet().stream()
                .max(Map.Entry.comparingByValue())
                .ifPresent(element -> System.out.println(format("Naczęstrszy gatunek filmowy to: {0}, liczba filmów: {1}", element.getKey(), element.getValue())));
    }

    /**
     * Do parsowania pliku można użyć np. własnego kodu, wyrażeń regularnych lub pliku
     * W tej metodzie zostały użyte wyrażenia regularne
     */
    private static String[] parseCSV(String line) {
        String regex = ",(?=([^\"]*\"[^\"]*\")*[^\"]*$)";
        String[] movie = line.split(regex);
        String title = movie[1].trim();
        if (title.charAt(0) == '"' && title.charAt(title.length() - 1) == '"') {
            movie[1] = title.substring(1, title.length() - 1).trim();
        }
        return movie;
    }

    /**
     * Sprawdzam czy String zawiera w sobie liczbę (jeden z filmów w zbiorze nie ma roku podanego)
     */
    private static boolean isNumeric(String str) {
        for (char c : str.toCharArray()) {
            if (!Character.isDigit(c)) return false;
        }
        return true;
    }

}

Wyzwanie Java #7: Programowanie funkcyjne

Sun, 27 May 2018 00:00:00 +0000

Do tej pory cały czas mówiliśmy, że Java jest językiem obiektowym. Poświęciliśmy temu zagadnieniu dwa dedykowane wyzwania, choć tak naprawdę już od pierwszego programu, gdyż użyliśmy słowa kluczowego class programowaliśmy obiektowo w Javie. Tak naprawdę tylko typy proste, ze względu na pewne optymalizacje, nie są obiektami, czyli jak już wiemy z poprzednich wyzwań, nie dziedziczą po java.lang.Object.

Jednak programowanie obiektowe, nie jest jedynym paradygmatem programowania jaki może wykorzystywać język programowania. Aktualnie coraz szersze zastosowania znajduje programowanie funkcyjne. Ma ono swoje podstawy już w latach trzydziestych XX wieku gdy to Alonzo Church opracował rachunek lambda. Dla przypomnienia, język Simula wprowadzający programowanie obiektowe został opracowany dopiero w latach sześćdziesiątych XX wieku. Pierwszym językiem funkcyjnym był IPL (Information Processing Language), jednak popularyzacja tego paradygmatu zaczęła się wraz z pojawieniem się języka LISP. Jednym z najpopularniejszych funkcyjnych języków programowania jest Haskell.

W programowaniu funkcyjnym, w odróżnieniu od programowania obiektowego, najważniejszym i zarazem jedynym narzędziem są funkcje. Funkcje mogą przyjmować na wejściu także funkcje oraz zwracać funkcje jako wynik. W przeciwieństwie do podejścia “klasycznego” gdzie opisywaliśmy zawsze jak coś zrobić krok po kroku, tutaj musimy napisać co ma być zrobione a już kompilator zajmie się całą resztą. Programista nie steruje także kolejnością wykonywania działań, definiuje jedynie szereg matematycznych zależności i funkcji. Pozbywamy się także wielu problemów znanych z świata obiektowego, czyli stan obiektu i jego synchronizacja w aplikacjach wielowątkowych, w programowaniu funkcyjnym nie ma czegoś takiego, przez co pisanie wielowątkowych i rozproszonych systemów staje się prostsze. W językach funkcyjnych także kod potrafi być od kilku do kilkudziesięciu razy zwięźlejszy i czytelniejszy niż analogiczny algorytm napisany w języku obiektowym. Dzięki tym zaletom, programowanie funkcyjne aktualnie rozkwita i jest coraz częściej stosowane. Niestety nie bez powodu czekaliśmy na ten moment tyle lat, takie podejście ma także swoje wady. Bardzo często programy stworzone w językach funkcyjnych są po prostu wolne. Nie da się także każdego problemu informatycznego tak łatwo przedstawić w postaci zbioru zależnych od siebie funkcji matematycznych bez uciekania się do tego wszystkiego co znamy z języków obiektowych. Dlatego też coraz więcej powstaje języków hybrydowych które pozwalają pisać swój kod zarówno w sposób obiektowy jak i funkcyjny.

Java od wersji 8 także zyskała wiele mechanizmów znanych z paradygmatu programowania funkcyjnego. Niektórzy twierdzą, że jest to najbardziej rewolucyjna i znacząca aktualizacja JVM. Mimo to, Java w dalszym ciągu jest językiem obiektowym. W tym poście będziemy chcieli poznać podstawy programowania funkcyjnego w Javie i nowości które weszły wraz z wersją ósmą.

Wyrażenia lambda

Przed chwilą dowiedzieliśmy się, że z językami funkcyjnymi związane są lambdy. Pomijając matematyczne wywody, lambda to tak naprawdę kawałek kodu który można przekazać do innego kawałka programu w celu wykonania. Czyli parametrem nie jest obiekt czy wartość, tylko nasz kod.

Wyobraźmy sobie że mamy kolekcję obiektów i chcemy tą kolekcję posortować. Zrobilibyśmy pewnie tak:

package pl.kodolamacz.func;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class LambdaExample {

    public static void main(String[] args) {

        List<String> words = Arrays.asList("Ala", "ma", "czarnego", "kota", "o", "imieniu", "Bonifacy");

        Collections.sort(words); // sortowanie kolekcji według naturalnego porządku

        System.out.println(words);

    }

}

Powyższy kod korzysta z klasy Collections i wbudowanej tam metody sort która wykonała nam co trzeba. Ale co jeśli chcielibyśmy posortować w odwrotnej kolejności lub z zachowaniem własnych innych reguł? Do tego służy tak zwany komparator:

package pl.kodolamacz.func;

import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class LambdaExample {

    public static void main(String[] args) {

        List<String> words = Arrays.asList("Ala", "ma", "czarnego", "kota", "o", "imieniu", "Bonifacy");

        Collections.sort(words, new WordComparator()); // sortowanie kolekcji odwrócone

        System.out.println(words);

    }

}

class WordComparator implements Comparator<String> {

    @Override
    public int compare(String o1, String o2) {
        return o2.compareTo(o1);
    }

}

W powyższym kodzie musieliśmy stworzyć dodatkową klasę która definiuje warunek sortowania. Moglibyśmy także tą klasę zdefiniować we wnętrzu klasy LambdaExample, tworząc tak zwaną klasę wewnętrzną:

package pl.kodolamacz.func;

import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class LambdaExample {

    static class WordComparator implements Comparator<String> {

        @Override
        public int compare(String o1, String o2) {
            return o2.compareTo(o1);
        }

    }

    public static void main(String[] args) {

        List<String> words = Arrays.asList("Ala", "ma", "czarnego", "kota", "o", "imieniu", "Bonifacy");

        Collections.sort(words, new WordComparator()); // sortowanie kolekcji odwrócone

        System.out.println(words);

    }

}

Gdybyśmy chcieli uprościć nasz kod możemy napisać coś takiego:

package pl.kodolamacz.func;

import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class LambdaExample {

    public static void main(String[] args) {

        List<String> words = Arrays.asList("Ala", "ma", "czarnego", "kota", "o", "imieniu", "Bonifacy");

        Collections.sort(words, new Comparator<String>() {

            @Override
            public int compare(String o1, String o2) {
                return o2.compareTo(o1);
            }

        }); // sortowanie kolekcji odwrócone

        System.out.println(words);

    }

}

Wykorzystaliśmy do tego tak zwaną klasę anonimową, czyli taką która nie ma nazwy (wcześniej WordComparator), mimo że robi dokładnie to samo co wcześniej. Często tworzenie takich klas “w locie” jest po prostu łatwiejsze i szybsze, niż definiowanie nowych klas i wymyślanie im nazw. Jedyny problem jest taki, że z takiej klasy nie skorzystamy już gdzieś indziej, tylko w tym miejscu naszego kodu.

Dzięki wyrażeniom lambda nasz kod może się uprościć jeszcze bardziej:

package pl.kodolamacz.func;

import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class LambdaExample {

    public static void main(String[] args) {

        List<String> words = Arrays.asList("Ala", "ma", "czarnego", "kota", "o", "imieniu", "Bonifacy");

        Collections.sort(words, (String o1, String o2) -> {return o2.compareTo(o1);}); // lambda

        System.out.println(words);

    }

}

Składnia lambdy jest dość prosta:

(parametry...) -> {kod}

Jeśli nie ma parametrów, wystarczy podać pusty nawias. Jeśli parametry mają typ którego kompilator potrafi się domyślić, można je pominąć:

Collections.sort(words, (o1, o2) -> {return o2.compareTo(o1);});

Jeśli kod jest tylko pojedynczym wyrażeniem, można pominąć klamry i słowo “return” otrzymując:

Collections.sort(words, (o1, o2) -> o2.compareTo(o1));

Lambdy można tworzyć tam gdzie parametrem jest interfejs z jedną metodą abstrakcyjną, w pozostałych przypadkach trzeba zaimplementować go standardowo. Takie interfejsy nazywamy funkcyjnymi.

Referencje do metod

Jeśli metoda której chcemy użyć w naszym komparatorze już istnieje, możemy jej także użyć w naszym wyrażeniu lambda. Możemy ją po prostu wywołać tak jak wcześniej:

package pl.kodolamacz.func;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class LambdaExample {

    public static void main(String[] args) {

        List<String> words = Arrays.asList("Ala", "ma", "czarnego", "kota", "o", "imieniu", "Bonifacy");

        Collections.sort(words, (o1, o2) -> o1.compareTo(o2)); // sortowanie kolekcji według naturalnego porządku

        System.out.println(words);

    }

}

ale możemy też przekazać samą funkcję compareTo

package pl.kodolamacz.func;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;

public class LambdaExample {

    public static void main(String[] args) {

        List<String> words = Arrays.asList("Ala", "ma", "czarnego", "kota", "o", "imieniu", "Bonifacy");

        Collections.sort(words, String::compareTo); // sortowanie kolekcji według naturalnego porządku

        System.out.println(words);

    }

}

Powyższe dwa kawałki kodu są identyczne w działaniu, zaś drugi jest dużo prostszy do napisania. Na uwagę zasługuje znak “::” wskazujący, że przekazujemy funkcję do wykonania.

Biblioteka strumieni

Ostatnią dużą nowością która weszła wraz z Javą w wersji 8 jest biblioteka strumieni. Umożliwiają one operacje na kolekcjach w zupełnie inny sposób, z wykorzystaniem tak zwanej wewnętrznej iteracji. Strumienie to tak naprawdę ciąg elementów, jeden po drugim, na których możemy wykonywać różne operacje.

Wyobraźmy sobie, że mając ten sam zbiór słów co wyżej, chcemy je wszystkie wyświetlić. Znając pętle z języka Java, moglibyśmy napisać taki kod:

package pl.kodolamacz.func;

import java.util.Arrays;
import java.util.List;

public class StreamExample {

    public static void main(String[] args) {
        List<String> words = Arrays.asList("Ala", "ma", "czarnego", "kota", "o", "imieniu", "Bonifacy");

        for (String word : words) {
            System.out.println(word);
        }
    }

}

Dzięki strumieniom powyższą pętlę foreach można zamienić na stream:

words.stream().forEach((String s) -> {System.out.println(s);});

lub łatwiej:

words.stream().forEach(s -> System.out.println(s));

czy nawet:

words.stream().forEach(System.out::println);

Cały program wtedy będzie wyglądać tak:

package pl.kodolamacz.func;

import java.util.Arrays;
import java.util.List;

public class StreamExample {

    public static void main(String[] args) {
        List<String> words = Arrays.asList("Ala", "ma", "czarnego", "kota", "o", "imieniu", "Bonifacy");

        words.stream().forEach(System.out::println);
    }

}

Gdybyśmy chcieli teraz dla przykładu zostawić tylko słowa dłuższe lub równe 3 literom możemy napisać tak:

package pl.kodolamacz.func;

import java.util.Arrays;
import java.util.List;

public class StreamExample {

    public static void main(String[] args) {
        List<String> words = Arrays.asList("Ala", "ma", "czarnego", "kota", "o", "imieniu", "Bonifacy");

        words.stream()
                .filter(s -> s.length() > 3)
                .forEach(System.out::println);
    }

}

Możemy też z łatwością zliczyć ile było elementów jednocześnie je wyświetlając:

package pl.kodolamacz.func;

import java.util.Arrays;
import java.util.List;

public class StreamExample {

    public static void main(String[] args) {
        List<String> words = Arrays.asList("Ala", "ma", "czarnego", "kota", "o", "imieniu", "Bonifacy");

        long count = words.stream()
                .filter(s -> s.length() > 3)
                .peek(System.out::println)
                .count();

        System.out.println("Elementów: " + count);
    }

}

Należy tylko zauważyć, że zmieniliśmy funkcję forEach na peek gdyż ta pierwsza wymaga zakończenia operacji na strumieniu, ta druga zaś pozwala dalej wykonywać operacje jak choćby nasz “count”.

Dzięki strumieniom możemy także łatwo przekształcać nasze zbiory w inne:

package pl.kodolamacz.func;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class StreamExample {

    public static void main(String[] args) {
        List<String> words = Arrays.asList("Ala", "ma", "czarnego", "kota", "o", "imieniu", "Bonifacy");

        List<String> newWords = words.stream()
                .map(String::toUpperCase)
                .collect(Collectors.toList());

        newWords.stream()
                .filter(s -> s.length() > 3)
                .forEach(System.out::println);
    }

}

W powyższym przykładzie kolekcja słów została zamieniona w kolekcję, że każde słowo jest pisane dużymi literami. Pobranie wyniku przetwarzania dzieje się w metodzie collect.

Powyższy program można by było uprościć także do takiej postaci:

package pl.kodolamacz.func;

import java.util.Arrays;
import java.util.List;

public class StreamExample {

    public static void main(String[] args) {
        List<String> words = Arrays.asList("Ala", "ma", "czarnego", "kota", "o", "imieniu", "Bonifacy");

        words.stream()
                .map(String::toUpperCase)
                .filter(s -> s.length() > 3)
                .forEach(System.out::println);
    }

}

Jak widać, biblioteka strumieni w Javie jest zarazem bardzo prosta i przejrzysta a jednocześnie oferuje niezwykle bogaty wachlarz funkcjonalności. Napisanie powyższych fragmentów kodu z użyciem pętli zamiast strumieni, kod byłby bardziej zawiły i wymagał chwili zastanowienia co tam się dzieje.

Wyzwanie

Czas na nasze wyzwanie. Chcielibyśmy, by za pomocą poznanej wiedzy, czyli strumieni, wyrażeń lambda oraz referencji do metod napisali program który wczyta zawartość pliku z filmami ze zbioru MovieLens (zbiór MovieLens 20M Dataset, plik movies.csv) i wyliczy następujące rzeczy:

Łączną ilość filmów w pliku
Przedział lat w jakim te filmy wyszły (daty są w nawiasie w tytule)
Najczęstszy gatunek filmowy
Ile filmów znajduje się w każdym gatunku filmowym

Wynik ma być wyświetlony w konsoli.

Książki które powinien przeczytać każdy programista Java

Thu, 24 May 2018 00:00:00 +0000

W dzisiejszym poście chciałbym przedstawić kilka książek które według mnie każdy kto chce zawodowo programować w Javie powinien przeczytać. Nie będą to oczywiście książki do nauki samego języka, tylko wiedza dużo szersza, choć wcale nie musisz być niezwykle doświadczonym programistą by zacząć je czytać, wręcz przeciwnie, niejeden młodszy programista może znacząco poprawić wynik swojej rozmowy kwalifikacyjnej po tej lekturze.

Część z tych książek została wydana w polskim tłumaczeniu, jednak podam nazwy oryginalnych wydań.

Effective Java 3 (Joshua Bloch)

Zaczynamy od najbardziej kultowej książki dla programistów, czyli Efective Java napisanej przez Joshua Blocha który przez długi czas pracując w Sun Microsystems rozwijał język i platformę Java. Obecnie pracuje w firmie Google. Jest jednym z największych ekspertów od języka Java uznanym na całym świecie.

Książka pokazuje jak wykorzystać język i platformę Java do granic jej możliwości pisząc dobry i wydajny kod. Pozwala także unikać wielu błędów popełnianych przez mniej doświadczonych programistów.

Clean Code (Robert C. Martin)

Kolejna książka z serii “tych które trzeba przeczytać”. Tym razem Clean Code (tytuł polskiej edycji: Czysty kod) Roberta Martina który w świecie Java jest znany jako Wujek Bob (ang. Uncle Bob). Jeśli kiedykolwiek usłyszycie tą nazwę, chodzi właśnie o tego człowieka. Wujek Bob jest autorem wielu znamienitych pozycji, to jest jedna z jego najbardziej znanych książek. Jego książki są pisane łatwym i przystępnym językiem, dlatego czyta je się bardzo szybko i przyjemnie.

Książka nie dotyczy tak naprawdę języka Java, jest przeznaczona dla wszystkich programistów, choć zamieszczone tam przykłady kodu są w języku Java, stąd ogromna popularność jego książek właśnie w tej grupie. Wujek Bob pokazuje w niej jak pisać dobry kod, czyli taki który łatwo utrzymać, łatwo testować, łatwo czytać, po prostu nie trzeba się za niego wstydzić.

Clean Coder (Robert C. Martin)

Skoro już jesteśmy przy Wujku Bobie, to kolejną jego wartą pozycją do przeczytania jest Clean Coder (tytuł polskiej edycji: Mistrz czystego kodu). W tej książce autor opisuje nie kod, tylko nas samych, czyli opowiada o tym co robić by stać się profesjonalistą na rynku pracy. Jest także dużo o testowaniu kodu, pracy w projekcie i współpracy z innymi programistami.

Clean Architecture (Robert C. Martin)

Ostatnia na naszej liście pozycja Wujka Boba to Clean Architecture (tytuł polskiej edycji: Czysta architektura). W tej książce autor opisuje uniwersalne reguły dotyczące architektury naszych aplikacji, czyli jak je projektować, jak separować kod, jak zapewnić porządek w projekcie i wiele wiele innych. Pozycja trochę trudniejsza od poprzednich, bo i temat bardziej zaawansowany, dlatego warto po nią chwycić po przeczytaniu dwóch wcześniejszych książek Wujka Boba.

Wzorce projektowe (Erich Gamma, Richard Helm, Ralph Johnson, John Vlissides)

Kolejna klasyka na liście książek. Dotyczy ona wzorców projektowych czyli dobrych praktyk i rozwiązań które możemy, a wręcz nawet powinniśmy, stosować w swoich aplikacjach. Wzorce projektowe są swoistego rodzaju niezbędnikiem na większości rozmowach kwalifikacyjnych i kursach programowania. Książka ta ma czterech autorów, który potocznie nazywani są Gangiem czterech (ang. Gang of Four, GoF). Dlatego potocznie wiele osób używa skrótu GOF właśnie do określania wzorców projektowych.

Powyższa książka należy do tych najbardziej znanych i rozpoznawalnych, ale istnieje wiele innych dobrych pozycji dotyczących wzorców projektowych, dlatego polecam po prostu wybranie dowolnej z nich.

The Pragmatic Programmer (David Thomas, Andrew Hunt)

The Pragmatic Programmer (tytuł polskiej edycji: Pragmatyczny programista) to kolejna bardzo dobrze oceniania i polecana książka dla wszystkich programistów. Autorzy pokazują szereg technik, podejść i rozwiązań pozwalających na zwiększenie efektywności naszej pracy.

Podsumowanie

Na tym zakończę listę. Tak naprawdę, można by było jeszcze bardzo długo wymieniać szereg znanych i cenionych książek, więc jeśli już przeglądaliście jakieś pozycje dotyczące programowania, mogliście pomyśleć sobie “przecież nie ma książki …”, jednak moim celem było wyselekcjonowanie tych naprawdę najbardziej podstawowych pozycji po które powinno się sięgnąć zaczynając swoją przygodę z programowaniem.

Wyzwanie Java #6: Operacje wejścia - wyjścia - rozwiązanie

Wed, 23 May 2018 00:00:00 +0000

Czas na rozwiązanie kolejnego wyzwania. Ten program także można było rozwiązać na wiele sposobów, wykorzystując różne możliwości języka Java. Poniżej jedno z możliwych rozwiązań:

package pl.kodolamacz.io;

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.text.MessageFormat;
import java.util.List;
import java.util.Scanner;

public class Exercise {

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);

        System.out.println("Proszę podać nazwę pliku wejściowego: ");
        String userSourceFilePath = scanner.nextLine();
        System.out.println("Proszę podać nazwę pliku wynikowego: ");
        String userResultFilePath = scanner.nextLine();

        Path sourcePath = Paths.get(userSourceFilePath);
        Path resultPath = Paths.get(userResultFilePath);

        try {

            if (Files.exists(sourcePath)) {

                List<String> lines = Files.readAllLines(sourcePath);
                Integer size = lines.size();

                System.out.println(MessageFormat.format("W pliku jest {0} linii.", size));

                Files.write(resultPath, size.toString().getBytes(), StandardOpenOption.CREATE); // flaga CREATE tworzy plik jeśli nie istniał
            }

        } catch (Exception e) {
            System.out.println("Błąd dostępu do pliku: " + userSourceFilePath);
        }

        scanner.close();
    }

}

Wyzwanie Java #6: Operacje wejścia - wyjścia

Sun, 20 May 2018 00:00:00 +0000

W dzisiejszym poście chcielibyśmy porozmawiać o operacjach wejścia wyjścia w Javie. Do tej pory nasze programy były zamknięte na świat, nie wykonywały żadnej komunikacji poza wyświetlaniem w konsoli informacji dla użytkownika i wczytywanie wprowadzonych przez niego danych. Jednak to zdecydowanie za mało, nasz program musi umieć robić takie rzeczy jak obsługa plików, komunikacja z bazami danych, przesyłanie i odbieranie danych po sieci czy integracja z innymi systemami lub urządzeniami.

Standardowe wejście i wyjście

Zaczniemy od standardowego wejścia i wyjścia w systemie operacyjnym. W naszym pierwszym wyzwaniu napisaliśmy taki program:

package pl.kodolamacz;

import java.util.Scanner;

public class MyFirstJavaApplication {

    public static void main(String[] args) {
        System.out.println("Witaj świecie!");

        Scanner scanner = new Scanner(System.in); // przekazujemy standardowe wejście (System.in)
        String userString = scanner.nextLine();
        scanner.close();

        System.out.println("Twój napis to: " + userString); // korzystamy ze standardowego wyjścia (System.out)
    }

}

Wykorzystaliśmy w nim klasę Scanner do komunikacji z użytkownikiem, dokładnie pobrania od niego imienia i wyświetlenia go w konsoli. Jednak klasa Scanner komunikuje się z systemem operacyjnym by pobrać wpisany przez użytkownika tekst w terminalu, dlatego korzysta ze specjalnego strumienia systemowego, tak zwanych standardowych strumieni.

Standardowe strumienie (Wikipedia)

Strumienie są właśnie mechanizmem komunikacji z innymi zasobami systemowymi i przesyłanie między naszym programem a nimi danych. Strumień to tak naprawdę sekwencja bajtów.

Na diagramie wyżej widzimy, że takie standardowe strumienie są w systemie trzy, standardowe wejście gdzie pobieramy informacje z klawiatury, standardowe wyjście gdzie wyświetlamy coś na ekranie oraz standardowe wyjście błędów gdzie także wyświetlamy coś użytkownikowi, ale są to informacje o błędach.

Zamykanie strumieni

Wiele osób pytało, dlaczego w naszym kodzie musimy użyć metody scanner.close. Wtedy było za wcześnie by to wytłumaczyć, więc zrobię to teraz.

W artykule o świecie Javy opisałem, że dzięki specjalnemu “odśmiecaczowi” (garbage collector) Java sama zarządza pamięcią operacyjną i tutaj, w przeciwieństwie do niektórych języków, nie musimy tej pamięci ani alokować ani dealokować, czyli zwalniać na inne potrzeby. Ze strumieniami jest jednak inaczej, bo często dotyczą zasobów typu Input/Output inaczej IO, czyli wejścia wyjścia, gdzie korzystamy z zasobów systemowych, które trzeba zamykać. Jeśli tego nie zrobimy możemy spowodować problem zwany “Resource leak” czyli wyciek zasobów. Dlatego wszystkie zasoby inne niż pamięć takie jak uchwyty do plików, otwarte sockety i tym podobne, trzeba samodzielnie zamykać. Zwłaszcza, że systemy operacyjne pozwalają zwykle na ograniczoną ilość otwartych zasobów systemowych. Oczywiście, sam system operacyjny, a dokładnie jego kernel czyli jądro systemu, może uznać, że jakiś zasób zostanie zamknięty, nawet jeśli program sam tego nie zrobił, ale zwykle dzieje się to dopiero gdy nasz program zostanie wyłączony. W naszym krótkim programie nic takiego wielkiego się nie stanie, jeśli tego nie zrobimy, ale trzeba pamiętać, że w Javie tworzy się często oprogramowanie, które działa miesiącami lub nawet latami bez restartu i wtedy prawidłowa obsługa strumieni jest niezwykle ważna.

W drugą stronę, jeśli spróbujemy zamknąć strumień dwukrotnie, lub wykonać jakąś akcję na nim po zamknięciu dostaniemy wyjątek “java.lang.IllegalStateException” lub podobny.

Obsługa wyjątków

Zanim jednak pójdziemy dalej, musimy powiedzieć sobie o jeszcze jednej ważnej rzeczy, mianowicie obsłudze wyjątków. Wyjątek to informacja, że w programie “coś poszło nie tak”. Problemem może być nasz kod, czyli typowy błąd programisty, ale niektóre błędy nie zależą od nas, na przykład chcemy odczytać plik który nie istnieje. W takiej sytuacji program wyrzuci wyjątek mówiący o tym, że nie odnaleziono pliku. Takie wyjątki, możemy także sami “wyrzucać” (ang. throw), jeśli napotkamy sytuację nieprawidłową, np. gdy użytkownik próbuje podzielić przez zero w naszym kalkulatorze.

Wyjątki w Javie to też jakieś obiekty, które dziedziczą po klasie java.lang.Exception. Klasa Exception dziedziczy zaś po klasie java.lang.Throwable. Nie zagłębiając się zbytnio w szczegóły, nasze wyjątki powinny dziedziczyć po klasie Exception a nie Throwable, dlatego, że ta druga klasa jest także klasą po której dziedziczy klasa java.lang.Error, która oznacza błędy krytyczne, np. związane z maszyną wirtualną, których to wyjątków także zwykła aplikacja nie obsługuje (łapie).

Skoro jednak Java “wyrzuci” nam wyjątek, to musimy umieć go “złapać” (ang. catch). Służą do tego składnia Try-Catch lub jej rozszerzenie Try-Catch-Finally (ewentualnie można też Try-Finally):

        try {
            // tutaj jakiś kod który może wyrzucić wyjątek
        } catch (Exception e){
            // ten kod zadziała tylko gdy będzie wyjątek
        } finally {
            // tutaj robimy coś na koniec
        }

W Javie 7 wprowadzono jeszcze jedną wersję obsługi błędów, mianowicie tak zwany try-with-resources, który pokażę za chwilę na przykładzie.

Pamiętajmy, że łapiemy klasę Exception lub te które po niej dziedziczą, a nie klasę Throwable!

Wyjątki w Javie dzielą się także na te które musimy “łapać” (checked) oraz takie których nie trzeba łapać (unchecked). Te pierwsze dziedziczą po klasie Exception zaś te drugie po klasie RuntimeException (która sama dziedziczy po Exception). Więcej można o tej decyzji przeczytać tutaj.

Jeśli byśmy kiedyś chcieli stworzyć własną metodę która wyrzuca wyjątek, powinniśmy użyć wtedy słowa throws mówiącego jakie wyjątki ona “może” wyrzucić, oraz słowa throw gdy coś pójdzie nie tak i będziemy chcieli ten wyjątek wyrzucić:

    public void thisMethodThrowsException() throws Exception {
        throw new Exception("Message...");
    }

Obsługa plików

W tym wyzwaniu skupimy się na obsłudze plików. Wykorzystamy tutaj zarówno API dostępne od pierwszych wersji Javy jak i nowe API zwane NIO (non-blocking I/O lub new I/O) wprowadzone w Javie 7.

Ścieżka do pliku

Pierwsze co nam będzie potrzebne, do ścieżka do pliku, czyli jego lokalizacja. W NIO służy do tego klasa Path:

Path pathToDirectory = Paths.get("/tmp/kodolamacz");
Path pathToFile = Paths.get("/tmp/kodolamacz/hello.txt")

Odczyt plików

Teraz możemy odczytać zawartość pliku z podanej ścieżki. Wystarczy użyć do tego klasy Files:

byte[] bytes = Files.readAllBytes(pathToFile);

Metoda zwraca nam zawartość w postaci tablicy bajtów. Gdy wiemy że ten plik jest tekstowy (u mnie taki jest), możemy przekonwertować to na obiekt klasy String za pomocą:

String fileContent = new String(bytes,Charset.defaultCharset());

Musimy jednak tam przekazać kodowanie naszego pliku. W powyższym przykładzie zakładamy, że plik jest zapisany w domyślnym kodowaniu.

Cały nasz program będzie wyglądał tak:

package pl.kodolamacz.io;

import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

public class InputOutputExample {

    public static void main(String[] args) {
        Path pathToDirectory = Paths.get("/tmp/kodolamacz");
        Path pathToFile = Paths.get("/tmp/kodolamacz/hello.txt");

        try {

            byte[] bytes = Files.readAllBytes(pathToFile);
            String fileContent = new String(bytes,Charset.defaultCharset());

            System.out.println("Zwartość pliku: ");
            System.out.println(fileContent);

        } catch (Exception e){
            // ten kod zadziała tylko gdy będzie wyjątek
            System.out.println("Dostaliśmy błąd obsługi pliku: " + e.getMessage());
        } finally {
            // tutaj robimy coś na koniec
        }
    }

}

Zapis do pliku

Jeśli nasz program zmienia zawartość pliku, możemy chcieć go na koniec zapisać. Nic prostszego, tutaj także wystarczy użyć klasy Files:

fileContent += " więcej tekstu..."; // dopisujemy coś do pliku
Files.write(pathToFile, fileContent.getBytes(Charset.defaultCharset()), StandardOpenOption.APPEND);

Nasz program ostatecznie będzie wyglądał tak:

package pl.kodolamacz.io;

import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

public class InputOutputExample {

    public static void main(String[] args) {
        Path pathToFile = Paths.get("/tmp/kodolamacz/hello.txt");

        try {

            byte[] bytes = Files.readAllBytes(pathToFile);
            String fileContent = new String(bytes, Charset.defaultCharset());

            System.out.println("Aktualna zawartość pliku: ");
            System.out.println(fileContent);

            fileContent += " więcej tekstu..."; // dopisujemy coś do pliku

            Files.write(pathToFile, fileContent.getBytes(Charset.defaultCharset()));

        } catch (Exception e) {
            // ten kod zadziała tylko gdy będzie wyjątek
            System.out.println("Dostaliśmy błąd obsługi pliku: " + e.getMessage());
        }
    }

}

Istnieje także możliwość wczytania naszego pliku jako listy linii tekstu a następnie ich zapisu jak w poniższym przykładzie:

package pl.kodolamacz.io;

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;

public class InputOutputExample2 {

    public static void main(String[] args) {
        Path pathToFile = Paths.get("/tmp/kodolamacz/hello.txt");

        try {

            List<String> lines = Files.readAllLines(pathToFile);

            System.out.println("Aktualna zawartość pliku: ");
            System.out.println(lines);

            lines.add(" więcej tekstu..."); // dopisujemy coś do pliku

            Files.write(pathToFile, lines);

        } catch (Exception e) {
            // ten kod zadziała tylko gdy będzie wyjątek
            System.out.println("Dostaliśmy błąd obsługi pliku: " + e.getMessage());
        }
    }

}

Istnieje także możliwość użycia do tego Stream API z Java 8 (nie mylić ze strumieniami danych opisanymi powyżej), ale temu poświęcimy kolejne wyzwanie.

Jednak z powyższymi metodami należy uważać gdy pliki są bardzo duże, bo w całości są wczytywane do pamięci. Jeśli nasz plik jest duży lepiej użyć strumienia do pliku i czytać go partiami, tak by w naszym programie nie zabrakło pamięci RAM, co mogłoby zawiesić lub zamknąć program.

To samo tyczy się także plików binarnych, wtedy także nie możemy użyć powyższych metod.

Odczyt strumieniowy plików

Musimy wtedy użyć bardziej niskopoziomowego (“surowego”) API i skorzystać z takich klas jak FileInputStream, FileReader, BufferedReader lub Scanner. Dwie pierwsze pracują wprost na bajtach, stąd wczytywania znak po znaku, kolejne już potrafią wczytać całe linie lub słowa. Poniżej przykład użycia tych czterech klas:

package pl.kodolamacz.io;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;
import java.util.Scanner;

public class InputOutputExample3 {

    public static void main(String args[]) {

        String path = "/tmp/kodolamacz/hello.txt";

        System.out.println("Przykład nr 1 - FileInputStream");
        try (FileInputStream inputStream = new FileInputStream(path)) {
            int character = inputStream.read();
            while (character != -1) {
                System.out.print((char) character);
                character = inputStream.read();
            }
            System.out.println(); // kończymy linię i zaczynamy nową
        } catch (IOException e) {
            System.out.println("Problem z odczytem pliku");
            e.printStackTrace();
        }

        System.out.println("Przykład nr 2 - FileReader");
        try (FileReader fileReader = new FileReader(path)) {
            int character = fileReader.read();
            while (character != -1) {
                System.out.print((char) character);
                character = fileReader.read();
            }
            System.out.println(); // kończymy linię i zaczynamy nową
        } catch (IOException io) {
            System.out.println("Problem z odczytem pliku");
            io.printStackTrace();
        }

        System.out.println("Przykład nr 3 - BufferedReader");
        try (BufferedReader bufferedReader = new BufferedReader(new FileReader(path))) {
            String line = bufferedReader.readLine();
            while (line != null) {
                System.out.println(line);
                line = bufferedReader.readLine();
            }
        } catch (IOException io) {
            System.out.println("Problem z odczytem pliku");
            io.printStackTrace();
        }

        System.out.println("Przykład nr 4 - Scanner");
        try (Scanner in = new Scanner(new FileReader(path))) {
            while (in.hasNext()) {
                String next = in.next();
                System.out.print(next + " ");
            }
        } catch (IOException io) {
            System.out.println("Problem z odczytem pliku");
            io.printStackTrace();
        }

    }

}

W powyższym kodzie została użyta nowa składnia try-with-resources wprowadzona w Javie 7. Pozwala ona na otwarcie strumienia we wnętrzu wyrażenia try:

try (BufferedReader bufferedReader = new BufferedReader(new FileReader(path))) {

co powoduje, że Java sama na koniec zamknie ten strumień. Oznacza to, że nie musimy troszczyć się o problemy opisane powyżej, związane z wyciekami zasobów. Wcześniej, gdy nie było tej instrukcji, nasz kod musiałby wyglądać tak jak niżej:

package pl.kodolamacz.io;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class InputOutputExample4 {

    public static void main(String args[]) {

        String path = "/tmp/kodolamacz/hello.txt";

        BufferedReader fileReader = null;
        try {
            fileReader = new BufferedReader(new FileReader(path));
            fileReader.readLine();
        } catch (IOException io) {
            System.out.println("Problem z odczytem pliku");
            io.printStackTrace();
        } finally {
            if (fileReader != null) {
                try {
                    fileReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

Dochodzi nam blok finally w którym zamykamy nasze strumienie. Kod w bloku finally wykonuje się zawsze, bez względu czy błąd wystąpił czy nie.

Klasy takie jak InputStream czy Reader możemy także tworzyć wykorzystując klasę Files:

InputStream inputStream = Files.newInputStream(pathToFile)
BufferedReader bufferedReader = Files.newBufferedReader(pathToFile, Charset.defaultCharset());

Inne operacje na plikach i katalogach

Klasa Files umożliwia nam wykonywanie wielu innych operacji na plikach i katalogach. Poniżej przykład kilku z nich:

package pl.kodolamacz.io;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

public class InputOutputExample5 {

    public static void main(String args[]) throws IOException {

        Path pathToDirectory = Paths.get("/tmp/kodolamacz-test");
        Path pathToFile = Paths.get("/tmp/kodolamacz/hello1.txt");
        Path pathToAnotherFile = Paths.get("/tmp/kodolamacz/hello2.txt");

        Files.createDirectory(pathToDirectory); // tworzy katalog
        Files.createDirectories(pathToDirectory); // tworzy katalog z katalogami pośrednimi

        Files.createFile(pathToFile); // tworzy pusty plik

        Files.copy(pathToFile, pathToAnotherFile); // kopiuje plik

        Files.delete(pathToAnotherFile); // usuwa plik

        Files.move(pathToFile, pathToAnotherFile); // przenosi plik
    }

}

Wyzwanie

Czas na nasze wyzwanie. Tym razem prosimy Was o napisanie programu który będzie operować na plikach.

Niech program poprosi użytkownika o podanie ścieżki do pliku wejściowego oraz wyjściowego gdzie będzie wynik. Następnie niech program wczyta plik wejściowy, zliczy w nim ilość linii, wyświetli tą liczbę użytkownikowi i zapisze nazwę pliku oraz liczbę linii w pliku wyjściowym.

Dla chętnych, prośba o dodanie obsługi błędów. Jeśli plik nie będzie istniał, niech program wyświetli o tym informację i poprosi o inny plik.

Wyzwanie Java #5: Interfejsy i dziedziczenie - rozwiązanie

Fri, 18 May 2018 00:00:00 +0000

Pora na rozwiązanie kolejnego wyzwania z drugiej części programowania obiektowego. Tym razem mieliśmy zaprojektować klasy do systemu wypożyczalni pojazdów.

To zadanie można rozwiązać na wiele sposobów, wszystko zależy od wymagań systemu i pomysłu programisty, dlatego bez obaw jeśli wasze klasy są kompletnie inne niż będą poniżej.

Zaczynamy od modelowania pojazdów. Zakładamy, że mamy samochody osobowe, dostawcze, motocykle i maszyny robocze. Każdy z nich jest pojazdem silnikowym i zakładamy, że nie będzie innych, uproszczając tym model. W takim razie stworzymy cztery klasy odpowiadające tym pojazdom i abstrakcyjną klasę pojazdu Vehicle (pomijamy podział na pliki *.java):

package pl.kodolamacz.vehiclerental.vehicle;

public class Vehicle {

}

public class Car extends Vehicle {
    
}

public class Motorbike extends Vehicle {

}

public class Van extends Vehicle {

}

public class WorkingMachine extends Vehicle {

}

Każdy pojazd ma swój numer rejestracyjny, numer vin, kolor, cenę, spalanie, stan zbiornika paliwa oraz licznik przejechanych kilometrów, dlatego nasza klasa Vehicle powinna zyskać następujące pola:

package pl.kodolamacz.vehiclerental;

import pl.kodolamacz.vehiclerental.engine.Engine;

public class Vehicle {

    private String registrationNumber;
    private String vin;
    private String color;
    private double price;
    private double combustion;
    private double fuel;
    private double kilometers;

}

W zależności od typu, pojazdy mogą mieć dodatkowe cechy jak np. liczba drzwi w przypadku aut osobowych, której to cechy nie będą mieć motocykle. Dlatego dla przykładu klasa samochodu osobowego może wyglądać tak:

package pl.kodolamacz.vehiclerental.vehicle;

import pl.kodolamacz.vehiclerental.Vehicle;

public class Car extends Vehicle {

   private int numberOfDoors;

}

Pojazdy będą mieć silnik diesla, silnik na benzynę lub elektryczny. By spełnić ten wymóg stworzymy sobie interfejs silnika (dowolnego, to ma być po prostu idea silnika):

package pl.kodolamacz.vehiclerental.engine;

public interface Engine {

    default void drive(){
        // domyślna metoda
    }

}

Interfejsy mają swoje implementacje czyli klasy które spełniają ten interfejs. W naszym wymaganiach mamy trzy wersje silników, dlatego stworzymy trzy klasy:

package pl.kodolamacz.vehiclerental.engine;

public class PetrolEngine implements Engine {

}

public class DieselEngine implements Engine {

}

public class ElectricEngine implements Engine {

}

Gdy mamy już “silniki” możemy uwzględnić to w naszym kodzie dla pojazdu, przez co nasza klasa zmieni się do takiej postaci:

package pl.kodolamacz.vehiclerental;

import pl.kodolamacz.vehiclerental.engine.Engine;

public class Vehicle {

    private String registrationNumber;
    private String vin;
    private String color;
    private double price;
    private double combustion;
    private double fuel;
    private double kilometers;
    private Engine engine;

}

Zauważcie ostatnie pole “engine” typu Engine, to właśnie nasz silnik w samochodzie. Ten sam samochód może mieć różne silniki, stąd tutaj mówimy że jest jakiś silnik, ale dopiero tworząc tą klasę “zainstalujemy” odpowiednią implementację!

Nasze “pojazdy” miały mieć metody jedź oraz tankuj, zmieniające pola licznika kilometrów oraz stanu zbiornika paliwa, dlatego dodajmy je:

package pl.kodolamacz.vehiclerental;

import pl.kodolamacz.vehiclerental.engine.Engine;

public class Vehicle {

    private String registrationNumber;
    private String vin;
    private String color;
    private double price;
    private double combustion;
    private double fuel;
    private double kilometers;
    private Engine engine;

    public void drive(double kilometers) {
        engine.drive(); // jadąc używamy silnika (metoda jest pusta, tylko pokazowo)
        this.kilometers += kilometers; // jadąc zwiększa się licznik kilometrów
        fuel -= combustion * kilometers; // zmniejsza się ilość paliwa w zależności od spalania
    }

    public void refuel(double fuel) {
        this.fuel += fuel;
    }

}

Jeśli zostawimy parametry jako “private” nikt z zewnątrz nie będzie miał do nich dostępu zarówno do zapisu jak i odczytu. Dlatego należałoby je zrobić jako dostępne (np. publiczne lub pakietowe) albo stworzyć możliwość dostępu do nich za pomocą odpowiednich metod (hermetyzacja). By móc stworzyć taką klasę należałoby dodać wtedy odpowiedni konstruktor lub ewentualnie metody dostępowe, tak zwane “settery”, które pozwoliłyby na ustawianie tych wartości. Z drugiej strony by móc odczytać wartości tych pól trzeba by było stworzyć metody dostępowe zwane “getterami”. Więcej o tym jak powinny wyglądać takie metody dostępowe, zarówno do zapisu pola (setter) jak i odczytu jego wartości (getter), można przeczytać w dokumentacji, jest to standard związany z Javą Enterprise Edition który dodaje tylko jako ciekawostkę dla osób które są już bardziej zaawansowane, w dalszej części ograniczymy się tylko do konstruktora, gdyż nie to było celem zadania.

Dodajmy zatem konstruktor z wszystkimi parametrami. W idei jest to dość proste, wystarczy użyć skrótu Alt + Insert i z listy wybrać opcję Constructor a potem wybrać wszystkie pola i nacisnąć OK. Nasza klasa zacznie wyglądać tak:

package pl.kodolamacz.vehiclerental;

import pl.kodolamacz.vehiclerental.engine.Engine;

public class Vehicle {

    private String registrationNumber;
    private String vin;
    private String color;
    private double price;
    private double combustion;
    private double fuel;
    private double kilometers;
    private Engine engine;

    public Vehicle() {
    }

    public Vehicle(String registrationNumber, String vin, String color, double price, double combustion, double fuel, double kilometers, Engine engine) {
        this.registrationNumber = registrationNumber;
        this.vin = vin;
        this.color = color;
        this.price = price;
        this.combustion = combustion;
        this.fuel = fuel;
        this.kilometers = kilometers;
        this.engine = engine;
    }

    public void drive(double kilometers) {
        engine.drive(); // jadąc używamy silnika (metoda jest pusta, tylko pokazowo)
        this.kilometers += kilometers; // jadąc zwiększa się licznik kilometrów
        fuel -= combustion * kilometers; // zmniejsza się ilość paliwa w zależności od spalania
    }

    public void refuel(double fuel) {
        this.fuel += fuel;
    }

}

Naszym pól w klasie jest całkiem sporo, przez co konstruktor wydaje się być skomplikowany, ale tak naprawdę jest bardzo prosty. W przyszłości moglibyśmy także pokusić się o zmniejszenie liczby tych parametrów korzystając z oddzielnych klas które je nam pogrupują lub kolekcji typu Map która przechowa je w jednym polu. Dodatkowo dodaliśmy konstruktor domyślny by nasz wcześniejszy kod się skompilował.

W klasie samochodu mieliśmy dodatkowe pole, dlatego tutaj też dodamy konstruktor plus użyjemy konstruktora z klasy Vehicle żeby ustawić pozostałe parametry:

package pl.kodolamacz.vehiclerental.vehicle;

import pl.kodolamacz.vehiclerental.Vehicle;
import pl.kodolamacz.vehiclerental.engine.Engine;

public class Car extends Vehicle {

   private int numberOfDoors;

    public Car(String registrationNumber, String vin, String color, double price, double combustion, double fuel, double kilometers, Engine engine, int numberOfDoors) {
        super(registrationNumber, vin, color, price, combustion, fuel, kilometers, engine); // tutaj konstruktor z klasy Vehicle, musi być jako pierwszy!
        this.numberOfDoors = numberOfDoors;
    }
    
}

Nasz program jest już prawie skończony, teraz wystarczy spróbować napisać kawałek kodu który użyje tych klas, na przykład tak:

package pl.kodolamacz.vehiclerental;

import pl.kodolamacz.vehiclerental.engine.PetrolEngine;
import pl.kodolamacz.vehiclerental.vehicle.Car;

public class VehicalRentalMain {

    public static void main(String[] args) {
        Car car = new Car("WZ 94567", "1M8GDM9A_KP042788", "Red", 40000, 6, 75, 0, new PetrolEngine(), 5);
        car.refuel(50); // tankujemy 50 litrów paliwa
        car.drive(100); // jedziemy 100 kilometrów
    }

}

Oczywiście program jest bardzo prosty, chodziło nam jedynie tutaj o próbę stworzenia odpowiedniego modelu klas a nie gotowego systemu wypożyczalni pojazdów. Modelowanie jest zagadnieniem tak naprawdę niezwykle ważnym a zarazem wcale nie takim prostym. Dlatego by dowiedzieć się więcej o prawidłowym tworzeniu klas i ich modelowaniu polecam poczytanie więcej o

Na rynku jest dostępna ogromna ilość książek poświęcona powyższym tematom.

Wprowadzenie do testowania aplikacji w środowisku Java

Wed, 16 May 2018 00:00:00 +0000

W tym poście powiemy sobie o jednym z najważniejszych aspektów tworzenia oprogramowania, mianowicie jego testowanie.

W środowisku programistów często powtarzane jest powiedzenie, że programowanie to tak naprawdę szukanie błędów i ich poprawianie. Christopher Thompson powiedział kiedyś: “Czasami bardziej opłaca się zostać w łóżku w poniedziałek niż spędzić resztę tygodnia, debugując poniedziałkowy kod”.

Każdy kto zetknął się z błędem używanego przez siebie oprogramowania, dobrze wie, jak frustrujące może to być dla użytkownika. Niestety są rzeczy gorsze, niż niezadowolony klient, błędy w oprogramowaniu mogą nieść ze sobą dużo bardziej druzgocące skutki. W skutek błędu w maszynie do radioterapii Therac-25, niektórzy pacjenci dostawali zbyt dużą dawkę promieniowania, przez co zmarło 5 osób. W 1966 roku, po 5 minutach lotu, awarii doznała sonda kosmiczna Mariner, błąd wynikał z nieprawidłowego przepisania wzoru z kartki i kosztował około 18,5 milionów dolarów. Przez błąd systemu obrony przeciwrakietowej PATRIOT w 1991 roku, nie udało się uniknąć ataku rakiety która zabiła 28 amerykańskich żołnierzy. Poprawka programu została wprowadzona następnego dnia… Zmiany w oprogramowaniu do projektowania CATIA i niezgodność wersji pomiędzy zespołami inżynierów pracujących nad projektem samolotu Airbus A380 spowodowały różnice w planach elektrycznych a tym samym niekompatybilność modułów, co spowodowało znaczne opóźnienie i dodatkowe koszta w wysokości ponad 6 miliardów dolarów. Błędy w oprogramowaniu przyczyniają się także do strat wynikających z użycia wirusów lub włamań komputerowych.

By uniknąć tych małych jak i tych większych błędów naszego oprogramowania coraz więcej w IT mówi się o testowaniu aplikacji. Jest to zagadnienie bardzo szerokie, zaś takie testy mogą odbywać się na wielu płaszczyznach, dlatego my tylko skupimy się na testach wykonywanych przez inżynierów oprogramowania.

Testowanie nie tylko zwiększa jakość i niezawodność naszego oprogramowania. Potrafi też znacząco ułatwić nam pracę. Początkowo, może się wydawać, że to strata czasu. Nasz projekt jest mały, mamy zapał do tworzenia nowego kodu a sprawdzenie czy wszystko działa zajmuje chwilę. Jednak z biegiem czasu, linijka za linijką, nasz kod jest coraz większy a program obsługuje coraz więcej funkcjonalności. Nagle przetestowanie wszystkiego by mieć pewność, że nasza mała zmiana nigdzie niczego nie popsuła potrafi zająć bardzo długi czas, a my mamy już dość robienia tego samego kolejny raz przez co przykładamy do tego mniej uwagi. W rezultacie boimy się wprowadzać większe zmiany, bo przecież “tamto działało” i chcemy ten stan zachować, zaś nasze testy są na tyle skąpe, że istnieje spora szansa, że i tak wszystkiego nie sprawdziliśmy. Tutaj z pomocą przychodzą nam właśnie testy. Stare powodzenie mądrego programisty mówi, jeśli robisz coś drugi raz ręcznie, zautomatyzuj to. Testy to nasz automat na usługach, który potrafi sprawdzić nam działanie naszego kodu i całej aplikacji w trakcie gdy my udamy się na krótką przerwę. Nie boimy się wprowadzać nawet największych zmian w naszym kodzie (np. tak zwanej refaktoryzacji), bo wiemy, że jeśli coś “popsujemy” to testy już o to zadbają, byśmy o tym wiedzieli. Takie testy także są dużo krótsze niż testowanie ręczne, samodzielne lub przez testerów, dlatego zachęcają do ich częstego używania, bez potrzeby uruchamiania naszej aplikacji. Dlatego okazuje się, że czas poświęcony na pisanie testów, w dłuższym rozrachunku do nas wraca! My za to śpimy spokojnie.

Kolejną bardzo dużą zaletą pisania testów do swojego kodu, jest swoistego rodzaju dokumentacja naszego kodu. Patrząc na testy w naszym kodzie, widząc co one sprawdzają, jaka funkcjonalność jest testowana, możemy bardzo szybko poznać co ten program robi, bez potrzeby analizowania samego kodu, linijka po linijce. Jest to bardzo przydatne czytając czyjś kod. Pracując w dużym zespole zawsze będziemy czytać i przeglądać kod naszych kolegów, testy jednocześnie ułatwiają nam to, z drugiej strony pilnują czy nasze zmiany nie spowodują problemów z czyimś kodem. Tą relację można odwrócić, czyli pisać testy zgodnie z naszymi wymaganiami do systemu czy przypadkami użycia.

Bywają też takie przypadki, że trafiamy do projektu który jest już prowadzony od dłuższego czasu, mającego wiele linii, mnóstwo funkcjonalności, brakuje dokumentacji a my nawet nie mamy się kogo spytać co się tam dzieje. Często taka aplikacja zależy od niewspieranego już systemu, języka, frameworku czy innych narzędzi. Mówimy wtedy o tak zwanym “Legacy Code” (polskie tłumaczenie “Odziedziczony kod”). Niestety takie systemy także nie mają zwykle testów, przez co praca z takim kodem przypomina trochę chodzenie po polu minowym. Michael Feathers, autor bardzo popularnej książki “Working Effectively with Legacy Code”, nazywa wręcz systemy “legacy” właśnie takimi które nie mają testów, mają ich bardzo mało lub same testy są nieprawidłowe. Wtedy jedną z zalecanych metod pracy w takim systemie jest właśnie rozpoczęcie pracy od napisania testów do niego i tym samym częściowo spłacenie tak zwanego “długu technologicznego”, czyli naprawienia niedociągnięć naszym poprzedników. Dobry zwyczaj skautów przecież nakazuje by pozostawiać swoje miejsce czystszym niż się je zastało!

Kolejną dużą zaletą testów, jest pomoc w dbaniu o nasz kod i ogólną architekturę aplikacji (często używane jest tutaj bardzo popularne w świecie IT, francuskie słowo “design”, jednak odnosi się znaczeniowo do aspektu wizualnego, np. dzieła sztuki, stąd nie będziemy go nadużywać, polskim odpowiednikiem jest słowo “wzornictwo” którego tutaj pewnie by nikt nie użył…). Okazuje się, że do złego kodu, gdzie panuje nieład i jest pisany niezgodnie ze sztuką, bardzo trudno napisać dobre testy. Bywają takie sytuacje, że to test powoduje, że programista upraszcza swój kod, by było go łatwiej przetestować a zyskuje na tym cały system.

Ostatnią zaletą i zastosowaniem naszych testów, jest możliwość wykorzystania ich do uczenia się nowych bibliotek, frameworków czy narzędzi. Po prostu piszemy testy do funkcjonalności których chcemy użyć. Z drugiej strony wiele narzędzi o otwartym kodzie jest pozbawionych dokumentacji, bądź jest bardzo uboga i wtedy przeglądając testy twórców tego narzędzia można naprawdę bardzo szybko się nauczyć wykorzystania tego narzędzia.

Podsumowując, piszemy testy by:

tworzyć dobre przetestowane programy (minimalizujemy prawdopodobieństwo błędów działania)
zapewnić lepszą architekturę (design) naszego systemu
nie bać się zmian (refaktoryzacja kodu)
nie psuć tego co było (regresja)
szybka informacja że coś poszło nie tak

Należy także pamiętać, że nie zawsze testy spełniają nasze powyższe wymagania. Dzieje się tak głownie wtedy gdy testy są bardzo słabe, niezgodne ze sztuką którą za chwilę będę chciał Wam przybliżyć. Wtedy niestety testy nie testują zbytnio naszego kodu, sprawiają tylko takie pozory, utrudniają nam pracę nad nowościami bo nagle ich utrzymanie i zmienianie wraz z systemem wymaga większego czasu niż pisanie samego kodu i dochodzimy do wniosku, że testy są niepotrzebne, wyłączamy je i ich już nie używamy albo wręcz usuwamy. Dlatego tak bardzo ważne jest, by nauczyć się pisać dobre testy, by dawały nam korzyści a nie były kulą u nogi.

Rodzaje testów

W świecie IT spotykamy wiele różnych rodzajów testów. Wyróżniamy tutaj testy:

Jednostkowe (tak zwane unit testy) - łatwe do tworzenia i modyfikacji, testują małą funkcjonalność, mały fragment kodu w oderwaniu od reszty systemu.
Integracyjne (inaczej testy warstwy serwisów) - w tych testach skupiamy się na sprawdzeniu czy nasze moduły / komponenty / fragmenty kodu potrafią ze sobą współpracować, testujemy samą ich integrację, bez wnikania czy te moduły są prawidłowe, gdyż to robią testy jednostkowe.
End-to-end (inaczej funkcjonalne lub akceptacyjne) - testy całościowe, sprawdzają jakąś funkcjonalność systemu w sposób całościowy, np. od wejścia do wyjścia gdy przetwarzamy jakieś dane, niekiedy też tutaj pojawiają się testy warstwy interfejsu dla użytkownika, czyli tak zwane testy UI (user interface), choć nie każdy system komputerowy taką warstwę w ogóle ma.

Zdarza się, że ludzie wprowadzają dodatkowe typy testów jak testy wydajnościowe czy testy penetracyjne (związane z bezpieczeństwem informatycznym), jednak trzy powyższe grupy są najbardziej uniwersalne, by nie rzecz najważniejsze, stąd skupimy się głownie na nich. Niekiedy też powyższe grupy są rozbijane na mniejsze.

Z racji tego, że testy jednostkowe są testy szybkie w działaniu, mają krótki kod i łatwo je tworzyć, znowu testy End-to-end są bardzo wolne, długotrwałe, trudne do napisania i utrzymania (edycji) stworzono coś takiego jak piramida testów.

Piramida testów

Piramida ta określa nam, które testy powinny być dominujące w naszym systemie a których powinno być najmniej. Oczywiście nie trudno się domyślić, że to małe i szybkie testy jednostkowe zajmują miejsce na spodzie naszej piramidy, czyli jest ich najwięcej, zaś testy całościowe są najrzadsze. Testy integracyjne są w centrum naszej piramidy. Często ludzie podają tutaj proporcje 70% - 20% - 10% ale w piramidzie nie chodzi o to by się sztywno trzymać tych proporcji, bo jeśli widzimy potrzebę napisania dodatkowego testu End-to-end to go napiszmy, nawet gdyby to miało oznaczać, że będzie ich 11% a nie 10%. Traktujmy piramidę jako wskazówkę, testuj co się da testami jednostkowymi, nigdy ich nie żałuj a integracyjnych i całościowych używaj tyle ile trzeba. Gdy proporcje piramidy są zaburzone, zastanów się czy testy integracyjne i End-to-end nie powinny być zastąpione jednostkowymi, bo testują tylko niewielką funkcjonalność systemu.

Kiedy pisać testy

Większość programistów pisze swoje testy po napisaniu kodu, czyli najpierw mała funkcjonalność, potem test jednostkowy który ją sprawdza. Istnieje jednak inne podejście związane z pisaniem kodu, czyli Test Driven Developmnet. Technika zwana w skrócie TDD zakłada pisanie testów na samym początku a dopiero potem kodu który zapewni w systemie spełnienie tego testu. Takie odwrócenie ma wiele zalet w stosunku do “klasycznego” podejścia, czyli twórz a potem sprawdź czy działa. Przede wszystkim, zawsze napiszemy te testy, nie ma tutaj miejsca na lenistwo lub brak czasu bo przekroczyliśmy termin oddania nowej funkcjonalności systemu. Takie testy przed kodem wymuszają także lepsze odwzorowanie testów i wymagań systemu a co za tym idzie testy są lepszej jakości i uwzględniają większą ilość kodu systemu podczas testowania (tak zwane pokrycie kodu testami).

Technika ta została zaproponowana przez Kenta Becka i polega w dużym skrócie na tworzeniu oprogramowania w trzech powtarzających się fazach:

Tworzymy testy do wymagań systemu (test oczywiście będzie nieudany na tym etapie)
Piszemy kod danej funkcjonalności który ma zapewnić działanie testu
Refaktoryzacja stworzonego kodu, tak by podnieść jego jakość i żeby spełniał standardy

Fani TDD potocznie te fazy nazywają Red, Green, Refaktor.

Jak to wygląda w praktyce

Można by długo jeszcze opowiadać o testach czysto teoretycznie, ale czas na kilka przykładów. Wykorzystamy do tego najpopularniejszą bibliotekę testującą dla środowiska Java jaką jest JUnit. Dodatkowo skorzystamy z narzędzia Apache Maven którego poznaliśmy tydzień temu. Na pokład wyciągniemy także program kalkulatora z wyzwania numer trzy.

Wprowadziliśmy tam klasę Fraction która miała reprezentować ułamek czyli licznik i mianownik wraz z częścią całkowitą.

Zaczynamy więc od napisania powyższych wymagań, tworzymy pusty projekt zgodnie z postem dotyczącym Apache Maven i zaczynamy programować tworząc taką klasę:

package pl.kodolamacz.math;

public class Fraction {

    private int fractionInteger;
    private int numerator;
    private int denominator;

}

Na razie idzie prosto. Jednak klasa jeszcze nic nie potrafi, pola są prywatne (hermetyzacja), więc tworząc taką klasę nie mamy nawet do nich dostępu… Dlatego stwórzmy sobie dodatkowo konstruktor tej klasy oraz funkcję która zwraca nam ułamek w postaci dziesiętnej, czyli po prostu typ double. Dostajemy zatem taki kod:

package pl.kodolamacz.math;

public class Fraction {

    private int fractionInteger;
    private int numerator;
    private int denominator;

    public Fraction(int fractionInteger, int numerator, int denominator) {
        this.fractionInteger = fractionInteger;
        this.numerator = numerator;
        this.denominator = denominator;
    }

    public double getFractionAsDecimal() {
        return fractionInteger + numerator / denominator;
    }

}

Na pierwszy rzut oka wszystko wygląda prawidłowo, konstruktor przyjmuje wszystkie trzy parametry, zaś metoda konwertująca do double zwraca zarówno część całkowitą jak i ułamek właściwy. Spróbujmy zatem to sprawdzić!

Zaczynamy od dodania do Mavena odpowiedniej biblioteki. Nasz plik pom.xml powinien wyglądać tak:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>pl.kodolamacz</groupId>
    <artifactId>java-challenges</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>

        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>5.2.0</version>
            <scope>test</scope>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.7.0</version>
                <configuration>
                    <source>10</source>
                    <target>10</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

Słowo scope w Mavenie ustawione na test oznacza, że ta biblioteka będzie używana tylko do testów ale nie trafi dla przykładu do stworzonych plików jar.

Dzięki JUnit możemy dodać swój pierwszy test w nowej klasie FractionTest:

package pl.kodolamacz.math;

import static org.junit.jupiter.api.Assertions.*;

class FractionTest {

}

Klasy tej jednak nie tworzymy w ścieżce “scr/main/java” tylko w “src/test/java”.

Jednak to dopiero początek, potrzebujemy metody która będzie testować naszą klasę Fraction:

package pl.kodolamacz.math;

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;

class FractionTest {

    @Test
    public void shouldGetFractionAsDouble(){
        // given

        // when

        // then
    }

}

Jak widać metoda swoją nazwą wprost pokazuje co tak naprawdę testuje, a właściwie czego wymaga od naszej klasy Fraction czyli “powinna zwrócić ułamek jako typ double”. Dodatkowo metoda ta została oznaczona adnotacją @Test wskazującą, że jest to metoda testowa i ma być specjalnie potraktowana przez framework testowy, czyli JUnit. Takich adnotacji jest kilkanaście i są one opisane na w dokumentacji projektu. Dzięki nim możemy na przykład sparametryzować testy, wykonywać jakieś akcje przed i po każdej metodzie testowej lub zbiorczo przed i po wszystkich metodach testowych w klasie testowej.

Dodatkowo test został podzielony na trzy logiczne części:

given - przygotowujemy dane testowe
when - wykonujemy test
then - sprawdzamy czy rezultat jest taki jak oczekiwany

Nie jest to wymóg by tak pisać testy, jednak jest to dobry zwyczaj który polecam.

Nasz test jednak jeszcze niczego nie robi, czas uzupełnić powyższe fazy:

package pl.kodolamacz.math;

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;

class FractionTest {

    @Test
    public void shouldGetFractionAsDouble() {
        // given
        Fraction fraction = new Fraction(1, 1, 2);

        // when
        double fractionAsDecimal = fraction.getFractionAsDecimal();

        // then
        assertEquals(1.5, fractionAsDecimal);
    }

}

W powyższym kodzie w fazie given stworzyliśmy obiekt typu Fraction, czyli nasz ułamek, w fazie when zwróciliśmy wartość double która ma ge reprezentować, zaś na koniec w fazie then sprawdzamy czy 1 i 1/2 to faktycznie 1,5.

Do sprawdzania używamy tak zwanych asercji czyli specjalnych metod z frameworku JUnit lub dodatkowej biblioteki, które pozwalają nam porównać wartość zwróconą z wartością oczekiwaną.

Uruchamiamy test (w idei np. klikając go prawym przyciskiem myszy i wybierając opcję Run) i ku naszemu zdziwieniu dostajemy błąd:

org.opentest4j.AssertionFailedError: 
Expected :1.5
Actual   :1.0
 <Click to see difference>


	at org.junit.jupiter.api.AssertionUtils.fail(AssertionUtils.java:56)
	at org.junit.jupiter.api.AssertEquals.failNotEqual(AssertEquals.java:197)
	at org.junit.jupiter.api.AssertEquals.assertEquals(AssertEquals.java:74)
	at org.junit.jupiter.api.AssertEquals.assertEquals(AssertEquals.java:69)
	at org.junit.jupiter.api.Assertions.assertEquals(Assertions.java:443)
	at pl.kodolamacz.math.FractionTest.shouldGetFractionAsDouble(FractionTest.java:18)
	at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)

Wygląda na to, że metoda która zwraca double ma błąd, tak zwany bug. Dzieje się tak dlatego, że dzieląc licznik przez mianownik oraz sumując go z częścią całkowitą pracujemy na liczbach typu int, czyli całkowitych, a dopiero potem wynik konwertujemy do typu double. Niestety przez to nasz wynik traci częścią niecałkowitą podczas operowania na liczbach całkowitych, stąd zamiast 1,5 dostajemy tylko wartość 1.

Należy zatem w klasie Fraction napisać tak:

package pl.kodolamacz.math;

public class Fraction {

    private int fractionInteger;
    private int numerator;
    private int denominator;

    public Fraction(int fractionInteger, int numerator, int denominator) {
        this.fractionInteger = fractionInteger;
        this.numerator = numerator;
        this.denominator = denominator;
    }

    public double getFractionAsDecimal() {
        return fractionInteger + (double) numerator / denominator;
    }

}

Gdy uruchomimy nasz test ponownie, dostajemy “zielony” wynik, czyli wszystko jest jak należy!

Narzędzia do testowania aplikacji napisanych w języku Java

JUnit nie jest jednym narzędziem używanym do testowania aplikacji, jest ich właściwie coraz więcej. Polecam przyjrzeć się takim projektom jak:

Do sprawdzania pokrycia kodu testami możemy użyć:

To nie są jedyne narzędzia wspomagające testowanie aplikacji w języku Java, jednak z całą pewnością jedna z najpopularniejszych i warto się przyjrzeć tym projektom.

Zakończenie

W tym poście chciałem Was zachęcić do testowania swojego kodu. Pokazałem zalety takiego testowania oraz podstawy ich tworzenia w środowisku Java. Niestety temat testowania aplikacji jest bardzo szeroki i długo można by było o nim mówić, dlatego już we własnym zakresie polecam dalsze zgłębianie tej wiedzy.

Wyzwanie Java #5: Interfejsy i dziedziczenie

Sat, 12 May 2018 00:00:00 +0000

W trzecim naszym wyzwaniu wprowadziliśmy Was w świat programowania obiektowego. Zrozumienie tego paradygmatu jest niezwykle ważne, by biegle posługiwać się językiem Java a także wieloma innymi językami obiektowymi. Niestety zrozumienie go i prawidłowe pisanie naszych programów obiektowych, nie jest wcale takie proste, dlatego wymaga większego zaangażowania i czasu by prawidłowo przyswoić niezbędną wiedzę.

W kolejnym naszym wyzwaniu, chcielibyśmy powtórzyć wiedzę którą poznaliśmy na temat programowania obiektowego i ją rozszerzyć.

Powiemy sobie o najważniejszych założeniach paradygmatu obiektowego, czyli:

Dziedziczeniu
Polimorfiźmie
Hermetyzacji
Abstrakcji

Dziedziczenie

Wyobraźmy sobie, że chcemy stworzyć aplikację dla pobliskiego ZOO. W tym systemie pracownicy wprowadzali by informacje o wszystkich zwierzętach którymi się opiekują. Dla przykładu, wśród zwierząt mielibyśmy lwy, tygrysy, słonie, żyrafy, papugi, orły i wiele wiele innych zwierząt. Przystępując do pracy na pewno stworzylibyśmy takie klasy:

public class Lion {

}

public class Elephant {

}

public class Eagle {

}

public class Parrot {

}

Każde z naszych zwierząt ma jakieś cechy, dla przykładu wagę, wiek oraz imię. Żeby móc w naszym programie zapisać te cechy, nasze klasy muszą mieć do tego odpowiednie pola, zatem nasz kod zacznie wyglądać jak poniżej:

public class Lion {

    public String name;
    public int age;
    public double weight;

}

public class Elephant {

    public String name;
    public int age;
    public double weight;

}

public class Eagle {

    public String name;
    public int age;
    public double weight;

}

public class Parrot {

    public String name;
    public int age;
    public double weight;

}

Dla ułatwienia, wszystkie zmienne oznaczymy jako “public”, choć docelowo dowiemy się, że nie jest to zbyt dobry pomysł. Jak widać, każdemu z naszym zwierząt możemy przypisać wszystkie trzy powyższe cechy, na przykład tak:

package pl.kodolamacz.zoo;

public class ZooApplication {

    public static void main(String[] args) {
        Elephant elephant1 = new Elephant();
        elephant1.name = "Hadoop";
        elephant1.weight = 7000;
        elephant1.age = 11;

        Elephant elephant2 = new Elephant();
        elephant2.name = "Dumboo";
        elephant2.weight = 6000;
        elephant2.age = 77;
    }

}

Jednak każdy od razu widzi, że w powyższym kodzie, powielamy w każdym obiekcie te same klasy! Od razu się nasuwa pytanie, czy nie można tego zrobić sprawniej, czyli poprzez zapisanie tego raz i współdzielenie z innymi klasami? Właśnie do tego służy dziedziczenie. Dzięki niemu, możemy stworzyć oddzielną klasę, np. zwierzę i odziedziczyć po niej zestaw cech które ma każde zwierzę!

Nasz kod dzięki temu może wyglądać tak:

public class Animal {

    public String name;
    public int age;
    public double weight;

}

public class Lion extends Animal {

}

public class Elephant extends Animal {

}

public class Eagle extends Animal {

}

public class Parrot extends Animal {

}

Polimorfizm

Dzięki stworzeniu klasy Animal i odziedziczeniu po niech zestawu cech dzięki słowu kluczowemu extends, wszystkie klasy zwierząt także mają te cechy. Dlatego nasz program w klasie ZooApplication może pozostać bez zmian.

Dzieje się tak dlatego, że obiekty elephant1 i elephant2 z klasy ZooApplication są jednocześnie słoniami (klasa Elephant) ale także zwierzętami (klasa Animal). Inaczej mówiąc, mają cechy z każdej z tych klas i można je w naszym programie traktować zarówno jako obiekty typu Elephant jak i Animal. Pokazuje to poniższy kod, gdzie obydwa obiekty zostały dodane do teoretycznie dwóch innych zbiorów.

package pl.kodolamacz.zoo;

import java.util.ArrayList;
import java.util.List;

public class ZooApplication {

    public static void main(String[] args) {
        Elephant elephant1 = new Elephant();
        elephant1.name = "Hadoop";
        elephant1.weight = 7000;
        elephant1.age = 11;

        Elephant elephant2 = new Elephant();
        elephant2.name = "Dumboo";
        elephant2.weight = 6000;
        elephant2.age = 77;

        Lion lion1 = new Lion();
        lion1.name = "Simba";
        lion1.weight = 100;
        lion1.age = 24;

        List<Elephant> elephants = new ArrayList<>();
        elephants.add(elephant1);
        elephants.add(elephant2);
        // elephants.add(lion1); // Tak nie możemy zrobić, lew nie jest słoniem!

        List<Animal> animals = new ArrayList<>();
        animals.add(elephant1);
        animals.add(elephant2);
        animals.add(lion1); // Tak już możemy, lew jest zwierzęciem!

        System.out.println("Liczba słoni: " + elephants.size());
        System.out.println("Liczba zwierząt: " + animals.size());
    }

}

Takie zachowanie nazywamy polimorfizmem czyli wielopostaciowością.

W świecie Java, każdy obiekt dziedziczy po wspólnym “przodku”, jest nim klasa java.lang.Object. Mimo, że tworząc swoją klasę, nie piszemy tego wprost, każda klasa która nie ma słowa extend rozszerza właśnie klasę Object. Oczywiście, jak chcemy, możemy napisać, że nasza klasa rozszerza klasę Object, ale jest to po prostu zbędne.

Trzeba także pamiętać, że dziedziczenie w Javie odbywa się zawsze zgodnie z zasadą IS-A, czyli jest, co oznacza, że słoń jest zwierzęciem, ale nie każde zwierze jest słoniem. Nie ma zatem w Javie takiego “dziedziczenia”, jakie znamy z biologii, czyli dziecko “dziedziczy” po swoich rodzicach, bo dziecko nie jest swoją mamą ani nie jest swoim ojcem, jednak wszyscy są ludźmi.

Hermetyzacja

Podczas dziedziczenia nie tylko cechy, czytaj pola klasy, są dziedziczone z innej klasy. Dotyczy to także metod. Jeśli nasza klasa Animal, miałaby jakieś metody, wszystkie klasy “potomne”, także będą mieć te metody (z dokładnością do widoczności o czym powiemy za chwilę).

Nasze “zwierze”, ma trzy cechy, imię, wiek i wagę. Imię jest cechą którą nadajemy, zaś wiek zmienia się wraz ze starzeniem się a waga jedząc. Nie wnikając w szczegóły i biologię ssaków, nasz program uwzględniający powyższe zasady powinien wyglądać tak:

package pl.kodolamacz.zoo;

public class Animal {

    private String name;
    private int age;
    private double weight;

    /**
     * Nazwyam zwierzę
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * Starzeje się, więc mój wiek wzrasta...
     */
    public void growOld(int age) {
        this.age += age;
    }

    /**
     * Jem więc staję się cięższy
     */
    public void eat(double weight) {
        this.weight += weight;
    }

}

oraz tak:

package pl.kodolamacz.zoo;

import java.util.ArrayList;
import java.util.List;

public class ZooApplication {

    public static void main(String[] args) {
        Elephant elephant1 = new Elephant();
        elephant1.setName("Hadoop");
        elephant1.eat(7000);
        elephant1.growOld(11);

        Elephant elephant2 = new Elephant();
        elephant2.setName("Dumboo");
        elephant2.eat(6000);
        elephant2.growOld(77);

        Lion lion1 = new Lion();
        lion1.setName("Simba");
        lion1.eat(100);
        lion1.growOld(24);

        // tutaj ciąg dalszy ...
    }

}

Zauważmy, że oprócz dodanie trzech nowych metod, nasze pola zmieniły się z public na private, czyli teraz nikt poza metodami z tej klasy, nie będzie miał dostępu do tych cech. Jakakolwiek zmiana ich wartości będzie wymagała dostępu przez metody setName, eat i growOld. Takie “ukrycie” implementacji, czyli wewnętrznego zachowania, nazywamy hermetyzacją. W praktyce, będziemy bardzo często spotykać się z hermetyzacją w naszych programach, pozwala ona na uniknięcie wielu potencjalnych błędów i ułatwia pisanie dużych programów, o czym sami się kiedyś przekonacie.

Abstrakcja

W naszym programie możemy stworzyć obiekty czterech klas: Lion, Elephant, Eagle oraz Parrot. Jednak, w celu ułatwienia sobie pisania kodu, stworzyliśmy dodatkową klasę Animal po której dziedziczą wszystkie inne i która służy do przechowania wszystkich “wspólnych” metod i cech obiektów. Jednak nikt nikomu nie zabroni napisania czegoś takiego w naszym programie:

Animal nieWiemCoTo = new Animal();

czyli stworzenia obiektu klasy Animal. Nie powinno tak być, gdyż nie ma w przyrodzie po prostu “zwierząt”, są za to lwy, słonie, orły i papugi. W języku polskim, pojęcia nie mające odpowiednika w konkretnym przedmiocie, coś bardziej ogólnego nazywamy abstrakcją. Tak samo jest i w Javie, to znaczy, klasy które są bytami ogólnymi, używanymi do celów dziedziczenia, ale nie służą do tworzenia żadnych konkretnych bytów, czyli obiektów, nazywamy klasami abstrakcyjnymi. By stworzyć klasę abstrakcyjną, wystarczy użyć słowa abstract w kodzie jak pokazano poniżej:

package pl.kodolamacz.zoo;

public abstract class Animal {

    private String name;
    private int age;
    private double weight;

    /**
     * Nazwyam zwierzę
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * Starzeje się, więc mój wiek wzrasta...
     */
    public void growOld(int age) {
        this.age += age;
    }

    /**
     * Jem więc staję się cięższy
     */
    public void eat(double weight) {
        this.weight += weight;
    }

}

Od teraz już nikt w naszym programie, nie będzie mógł stworzyć obiektu z klasy Animal.

Klasy abstrakcyjne, mogę mieć także metody abstrakcyjne, czyli takie które muszą być stworzone w klasie dziedziczącej po niej, lecz tutaj jedynie stwierdzamy, że taka metoda ma powstać. Gdyby chcieć nasze metody zmienić w abstrakcyjne, wystarczyłoby napisać tak:

package pl.kodolamacz.zoo;

public abstract class Animal {

    private String name;
    private int age;
    private double weight;

    /**
     * Nazwyam zwierzę
     */
    public abstract void setName(String name);

    /**
     * Starzeje się, więc mój wiek wzrasta...
     */
    public abstract void growOld(int age);

    /**
     * Jem więc staję się cięższy
     */
    public abstract void eat(double weight);

}

Za chwilę poznamy inny mechanizm “zmuszenia” programisty do napisania jakichś metod, mianowicie interfejsy. Zauważmy, że metody abstrakcyjne, nie mają ciała, jedynie definiujemy nazwę, parametry, zwracany typ oraz widoczność metody.

Widoczność pól i metod

W dziedziczeniu pól i metod jest jednak pewne ograniczenie, mianowicie, nie można odziedziczyć pól i metod oznaczonych jako private, użycie tego słowa zamiast public spowodowałoby, że tylko metody znajdujące się w klasie Animal miałyby dostęp do tego pola. Tak stało się z polami, gdy wprowadziliśmy trzy metody dostępu do pól, czyli eat, setName i growOld.

Dla przypomnienia, jeszcze raz tabela modyfikatorów dostępu wraz z oznaczeniem kto ma dostęp do danego pola lub metody:

	Klasa	Pakiet	Podklasa	Wszyscy
public	+	+	+	+
protected	+	+	+
default	+	+
private	+

Dziedziczenie i przesłanianie metod

Z dziedziczeniem metod, wiąże się jeszcze jedna bardzo ważna cecha, metody można nadpisywać. Wszystkie zwierzęta jedzą, jednak różne zwierzęta, mogą jeść w inny sposób. Wyobraźmy sobie, że u słoni tylko połowa jedzenia jest przetwarzana na masę (waga), zaś u wszystkich innych zwierząt będzie to całość. Nasz kod mógłby wyglądać na przykład tak:

package pl.kodolamacz.zoo;

public abstract class Animal {

    private String name;
    private int age;
    private double weight;

    /**
     * Nazwyam zwierzę
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * Starzeje się, więc mój wiek wzrasta...
     */
    public void growOld(int age) {
        this.age += age;
    }

    /**
     * Jem więc staję się cięższy
     */
    public void eat(double weight) {
        this.weight += 3/4 * weight;
    }

}

oraz:

package pl.kodolamacz.zoo;

public class Elephant extends Animal {

    /**
     * Słoń je trochę inaczej
     */
    @Override
    public void eat(double weight) {
        this.weight += 1/2 * weight;
    }

}

Jak widzimy, słoń, czyli klasa Elephant ma własną wersję metody eat, mimo że w klasie Animal już jest ona stworzona. Mówimy tutaj o nadpisaniu metody, co dodatkowo zaznaczone jest nieobowiązkową adnotację @Override. W tym momencie, gdy wykonamy metodę eat na obiektach klasy Elephant, zostanie użyta nowa implementacja.

Z racji tego, że przy wielokrotnym dziedziczeniu, tworzy się coś w rodzaju drzewa klas, zawsze używana jest implementacja z klasy będącej najdalej od klasy Object w tym drzewie. Przypomina to trochę stos kart, gdzie zawsze bierzemy to co najbliżej góry i zawsze kolejna karta nadpisuje te pod spodem.

Powyższy kod będzie jednak działał pod warunkiem, że pole weight w klasie Elephant nie będzie prywatne (patrz tabela modyfikatorów dostępu). Oznaczać to wtedy będzie, że nie możemy z tego pola skorzystać w klasie Elephant. Możemy jednak wtedy wywołać metodę eat z klasy po której dziedziczymy. Można to zrobić za pomocą słowa super. Poniżej przykład użycia tego słowa:

package pl.kodolamacz.zoo;

public class Elephant extends Animal {

    /**
     * Słoń je trochę inaczej
     */
    @Override
    public void eat(double weight) {
        super.eat(1 / 2 * weight);
    }

}

Jak widać w metodzie eat klasy Elephant odwołujemy się do metody eat klasy Animal. Oczywiście, w tej metodzie możemy odwołać się także do każdej innej metody z klasy Animal lub Elephant, jednak gdy w obydwu klasach będą istniały metody o tej samej nazwie, czytaj nadpisane, wtedy słowo super pozwala nam wskazać, że chcemy wykonać metodę z klasy po której dziedziczymy lub innej niżej w hierarchii klas w drzewie dziedziczenia.

Konstruktory

Wiemy, że do stworzenia obiektu, używana jest “specjalna” metoda zwana konstruktorem. Okazuje się, że one także podlegają zasadą dziedziczenia. Tworząc nowy obiekt, najpierw wykonywany jest konstruktor klasy Object a następnie po kolei wszystkie konstruktory powyżej, czyli w naszym przypadku najpierw konstruktor klasy Animal a następnie konstruktor klasy Elephant.

Także w przypadku konstruktorów, można skorzystać ze słowa super, z tym, że nie używamy wtedy znaku kropki. Poniżej przykład użycia dwóch różnych konstruktorów:

package pl.kodolamacz.zoo;

public abstract class Animal {

    private String name;
    private int age;
    private double weight;

    public Animal() {
        System.out.println("Tworzę zwierzę bez imienia...");
    }

    public Animal(String name) {
        this.name = name;
        System.out.println("Tworzę zwierzę o imieniu " + name);
    }

    /**
     * Nazwyam zwierzę
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * Starzeje się, więc mój wiek wzrasta...
     */
    public void growOld(int age) {
        this.age += age;
    }

    /**
     * Jem więc staję się cięższy
     */
    public void eat(double weight) {
        this.weight += 3 / 4 * weight;
    }

}

package pl.kodolamacz.zoo;

public class Elephant extends Animal {

    public Elephant() {
        super(); // tą linijkę można pominąć, jest domyślna
        System.out.println("Tworzę słonia bez imienia...");
    }

    public Elephant(String name) {
        super(name); // wybieramy konstruktor z parametrem
        System.out.println("Tworzę słonia o imieniu " + name);
    }

    /**
     * Słoń je trochę inaczej
     */
    @Override
    public void eat(double weight) {
        super.eat(1 / 2 * weight);
    }

}

package pl.kodolamacz.zoo;

import java.util.ArrayList;
import java.util.List;

public class ZooApplication {

    public static void main(String[] args) {

        Elephant elephant1 = new Elephant();
        elephant1.setName("Hadoop");
        elephant1.eat(7000);
        elephant1.growOld(11);

        Elephant elephant2 = new Elephant("Dumboo");
        // elephant2.setName("Dumboo"); // już niepotrzebne, mamy konstruktor
        elephant2.eat(6000);
        elephant2.growOld(77);
    }

}

Po uruchomieniu programu dostaniemy:

Tworzę zwierzę bez imienia...
Tworzę słonia bez imienia...
Tworzę zwierzę o imieniu Dumboo
Tworzę słonia o imieniu Dumboo

Interfejsy

A teraz sobie skomplikujmy sytuację. Mamy cztery zwierzęta: słoń, lew, papuga, orzeł. Dwa z nich to ssaki, dwa ptaki. Dwa są mięsożerne, dwa nie. Pojawia się problem, jak zbudować drzewo dziedziczenia przy takich relacjach. Można by spróbować wprowadzić dodatkowe klasy dla ssaków i patków, wtedy słoń dziedziczył by po ssaku, zaś ssak po zwierzęciu, czyli klasie Animal. Jednak to nie rozwiąże problemu z jedzeniem mięsa, bo nie każdy ssak jest mięsożerny i nie każdy ptak również. Dlatego by rozwiązać ten problem, wymyślono zupełnie inny mechanizm zwany interfejsami.

Interfejs to zestaw wymagań które stawiamy przed danym obiektem/klasą. W praktyce przekłada to się na zestaw metod które ta klasa musi mieć, by mogła implementować ten interfejs. Dlatego mówimy o interfejsach i ich implementacjach. Każdy interfejs może mieć wiele implementacji, oraz dowolna klasa może implementować wiele interfejsów.

Poniżej przykład takiego interfejsu dla mięsożercy i roślinożercy:

package pl.kodolamacz.zoo;

public interface Carnivore {

    void eatMeat(double weight);

}

package pl.kodolamacz.zoo;

public interface Herbivore {

    void eatPlant(double weight);

}

Ich użycie zaś będzie wyglądać tak:

package pl.kodolamacz.zoo;

public class Elephant extends Animal implements Herbivore {

    /**
     * Słoń je trochę inaczej
     */
    @Override
    public void eat(double weight) {
        super.eat(1 / 2 * weight);
    }

    @Override
    public void eatPlant(double weight) {
        eat(weight); // Nie ma słowa super, używamy metody eat z klasy Elephant!!!
    }

}

package pl.kodolamacz.zoo;

public class Lion extends Animal implements Carnivore{

    @Override
    public void eatMeat(double weight) {
        eat(weight); // tutaj także słowo super nie jest potrzebne bo nie ma konfliktu nazw
    }

}

package pl.kodolamacz.zoo;

public class Parrot extends Animal implements Herbivore {

    @Override
    public void eatPlant(double weight) {
        eat(weight);
    }

}

Dzięki temu zabiegowi słoń będący obiektem klasy Elephant jest zwierzęciem ale także roślinożercą. Odbywa się to dzięki użyciu słowa specjalnego implements w klasie implementującej dany interfejs.

Poniżej przykład użycia interfejsów w naszym programie:

package pl.kodolamacz.zoo;

import java.util.ArrayList;
import java.util.List;

public class ZooApplication {

    public static void main(String[] args) {

        Elephant elephant1 = new Elephant();
        elephant1.setName("Hadoop");
        elephant1.eat(7000);
        elephant1.growOld(11);

        Elephant elephant2 = new Elephant();
        elephant2.setName("Dumboo");
        elephant2.eat(6000);
        elephant2.growOld(77);

        Lion lion1 = new Lion();
        lion1.setName("Simba");
        lion1.eat(100); // możemy tak
        lion1.eatMeat(100); // lub tak
        // lion1.eatPlant(100); // ale nie tak...
        lion1.growOld(24);

        Parrot parrot1 = new Parrot();
        parrot1.setName("Ara");
        parrot1.eatPlant(1);
        parrot1.growOld(5);

        List<Elephant> elephants = new ArrayList<>();
        elephants.add(elephant1);
        elephants.add(elephant2);

        List<Animal> animals = new ArrayList<>();
        animals.add(elephant1);
        animals.add(elephant2);
        animals.add(lion1);
        animals.add(parrot1);

        List<Herbivore> herbivores = new ArrayList<>();
        herbivores.add(elephant1);
        herbivores.add(elephant2);
        herbivores.add(parrot1); // papuga jest rożlinożercą!
        // herbivores.add(lion1); // tak nie można!

        System.out.println("Liczba słoni: " + elephants.size());
        System.out.println("Liczba roślinożerców: " + herbivores.size());
        System.out.println("Liczba zwierząt: " + animals.size());
    }

}

Od wersji ósmej języka Java, interfejsy mogą mieć także domyślne implementacje metod, nie tylko jak powyżej, samą definicję, że takie metody mają istnieć:

package pl.kodolamacz.zoo;

public interface Carnivore {

    void eatMeat(double weight);

    default void roar() {
        System.out.println("ROARRRRR....");
    }

}

Dzięki temu, każda klasa implementująca interfejs Carnivore będzie potrafiła “ryczeć”. Jednak nic nie stoi na przeszkodzie, by nadpisać tą implementację własną. Interfejsy mogą także mieć pola i metody statyczne.

Wyzwanie

A teraz czas na wyzwanie. Tym razem zadanie będzie projektowe a nie algorytmiczne jak było to w przypadku wyzwania dotyczącego Algorytmów i struktur danych w Javie.

Celem wyzwania jest stworzenie klas do systemu wypożyczalni pojazdów. Każdy pojazd ma swój numer rejestracyjny, numer vin, kolor, cenę, spalanie, stan zbiornika paliwa oraz licznik przejechanych kilometrów. Samochody dzielimy na osobowe, dostawcze, motocykle i maszyny robocze. W zależności od typu, pojazdy mogą mieć dodatkowe cechy jak np. liczba drzwi w przypadku aut osobowych, której to cechy nie będą mieć motocykle. Pojazdy będą mieć silnik diesla, silnik na benzynę lub elektryczny. Należy korzystając z klas i interfejsów stworzyć model obiektowy tego systemu. Całość należy przetestować analogicznie do klasy ZooApplication, tworząc po kilka przykładowych samochodów. Klasy powinny mieć odpowiednie konstruktory oraz metody jedź oraz tankuj, zmieniające pola licznika kilometrów oraz stanu zbiornika paliwa.

Wprowadzenie do Apache Maven, czyli jak tworzy się projekty w świecie Java

Thu, 10 May 2018 00:00:00 +0000

Projekty informatyczne mają to do siebie, że z czasem się bardzo rozrastają. Sam proces budowania aplikacji staje się dość skomplikowany. Zbudowanie jednego projektu może być uzależnione od zbudowania innego, wersje projektów/bibliotek z czasem mogą się zmieniać na wyższe lub po prostu dochodzić mogą nowe biblioteki. Programiści są leniwi - nie będzie przecież taki człowiek teraz brał i ręcznie ściągał nowe wersje bibliotek i zastępował starsze. Albo pamiętał, że najpierw musi zbudować projekt CommonUtils aby potem projekt MailService mógł korzystać z nowych klas, które można wykorzystać do wysyłania emaili. Mało tego - taki programista musi pamiętać, aby przed zbudowaniem aplikacji - odpalić wszystkie testy, które sprawdzą czy jakaś funkcjonalność przez przypadek nie została zepsuta podczas aktualnych prac.

Programiści postanowili więc stworzyć narzędzie, które będzie te wszystkie czynności (i wiele więcej) robiło samo. Mało tego, ma ono pamiętać jaki projekt od którego zależy, w przypadku zmian wersji bibliotek sam ma to zauważyć i sam ściągnąć je z Internetu, ma sam odpalić testy i pilnować aby przechodziły a na koniec tak zbudowaną aplikację wrzucić na serwer produkcyjny i odpalić nowo zbudowaną aplikację. Czyż to nie piękne? Ile rzeczy, które dotychczas były na głowie programisty zniknęło? Programista ma zająć się pisaniem kodu a nie konfigurować, pamiętać, wykonywać jakieś magiczne skrypty itp.

Na tego typu okazję został stworzony Maven jako następca już prawie wymarłego ANT’a. Maven potrafi zrobić wszystko z naszym projektem podczas jego budowania. Jedyne co my musimy zrobić to zastosować się do konwencji nazewnictwa katalogów w projekcie jaką wymaga Maven. Jeśli to zrobimy - to już sam Maven zatroszczy się o kompilowanie kodu, wykonywanie testów itp. My jedynie będziemy mu wydawali polecenia - on sam ogarnie resztę.

Dlaczego to wszystko jest ważne? Oprócz oczywistych oszczędności czasu i odbarczeniem programisty rzeczami, które on nie powinien się zajmować - można wyróżnić szereg innych zalet jakie daje Automatyzacja procesu budowania aplikacji:

automatyczna kompilacja kodu
usunięcie starych plików z poprzedniego budowania aplikacji
pilnowanie kolejności budowania modułów aplikacji (pilnowanie zależności projektu od projektu)
pilnowanie bibliotek oraz ich wersji
wykonywanie testów aplikacji
generowanie pliku .jar (.war) z naszą aplikacją
generowanie dokumentacji
uniwersalność środowiska/konfiguracji - działa u mnie? powinno działać u Ciebie!
i wiele innych

Wszystkie te rzeczy składają się na jeden wielki proces budowania naszej aplikacji. Gdybyśmy przecież chcieli zbudować aplikację sami krok po kroku to bardzo często byśmy gdzieś się pomylili, o czymś zapomnieli. Wtedy aplikacja nie zbuduje się, bądź zbuduje się niepoprawnie - a my nawet możemy nie być tego świadomi. Maven zatroszczy się o wszystko. Począwszy od stworzenia projektu poprzez kompilację, testy jednostkowe, integracyjne, tworzenie dokumentacji i deploy’owanie gotowego programu w miejscu docelowym. Wszystko za pomocą nawet jednej komendy. Mało tego - jeśli ściągamy jakąś bibliotekę, która wymaga do swojego działania innej (zależy od niej) to Maven to zauważy i dociągnie tą zależność. Często jest tak, że ściągając jakąś bibliotekę - dociąga ponad 20-30 bibliotek zależnych (nasza biblioteka zależała od biblioteki B, B zależała od C i D, D od F oraz J…..). Śmiem twierdzić, że samemu próbując ściągać kolejne biblioteki, odpalając program i zauważając w logach, że brakuje kolejnej - dociągać ją, znów patrzeć w logi… i próbować te 30 bibliotek ściągać ręcznie - po 1h darowalibyśmy sobie przygodę z programowaniem. Na szczęście jest Maven :)

Zamiast opowiadać o Mavenie - zobaczmy go w akcji.

Instalacja Mavena

Mavena się instaluje w swoim systemie. Instalacja - to może za dużo powiedziane - rozpakowuje się go z archiwum i dodaje plik mvn do PATH systemu, aby można było go używać w systemie. Więcej tutaj.

Jednak gdy korzystamy z IntelliJ IDEA to mamy tam wbudowaną wersję Mavena która nam w zupełności wystarczy.

Pierwsza aplikacja stworzona za pomocą Apache Maven

Rozpocznijmy więc od stworzenia naszej pierwszej aplikacji zarządzanej przez Mavena. Wybieramy w IntelliJ IDEA:

File → New → Project…
Zakładka Maven → wybieramy wersję Java SDK na 10 → Next
Wypełniamy pola: ** GroupId: wpiszmy np. pl.kodolamacz ** ArtifactId: firstApp ** Version: 1.0-SNAPSHOT
klikamy Next
nazywamy projekt firstApp i wskazujemy jego lokalizację na dysku → klikamy Next
klikamy Finish

W ten sposób powstał szkielet naszej aplikacji. Gdy przyjrzymy się temu co powstało - zobaczymy następującą strukturę katalogów:

|- src 
|    \
|     |- main 
|     |     \
|     |     |- java
|     |     |- resources
|     |- test
|           \
|           | - java
|           | - resources
|- target
|- pom.xml

Wyjaśnijmy co jest czym:

Folder	Znaczenie
src/main/java	nasz kod Java projektu (tu kodujemy)
src/main/resources	pliki konfiguracyjne dla klas Java, np. dla różnych bibliotek itp.
src/test/java	kod Java dla testów aplikacji
src/test/resources	pliki konfiguracyjne dla klas testowych
target	folder gdzie Maven produkuje wszystkie owoce swojej pracy
pom.xml	główny plik konfiguracyjny projektu

Czym są foldery resources? Wykorzystuje się często do umieszczania wszelkiej maści plików pomocniczych. Bardzo często wykorzystujemy w projektach jakieś pliki które inicjują naszą aplikację (jakieś nasze własne pliki słowników wczytywane podczas startu aplikacji) albo pliki konfiguracyjne elementów aplikacji - wtedy dobrym miejscem na ich umieszczenie są foldery resources. Różnica między tym umieszczonym w folderze src a tym umieszczonym w folderze test jest taka, że ten z folderu test jest wykorzystywany w fazie testowania aplikacji (sprawdzania czy aplikacja działa jak powinna) i nie zostanie dołączony do finalnego pliku naszej aplikacji (np. jar) podczas budowania.

No dobrze - posiadamy już jakiś kod, którym możemy zarządzać Mavenem. Aby to jednak zrobić musimy być świadomi jak pracuje Maven. Zamysł jego działania opiera się o tzw. cykle życia (build lifecycle). Cykle życia składają się z faz, które są kolejnymi elementami na drodze od kodu źródłowego do projektu uruchomionego np. na serwerze. Istnieją 3 podstawowe cykle życia:

clean - czyści po sobie poprzednie efekty budowania aplikacji (często oznacza to wyczyszczenie folderu target)
site - buduje dokumentację projektu (np. tzw. javadoc)
domyślny cykl, który z kolei składa się z następujących faz (w prawidłowej kolejności):

Faza	Wyjaśnienie
validate	validuje strukture projektu
compile	kompiluje kod źródłowy
test	uruchamia testy
package	tworzy artifact w katalogu określonym jako ‚target’
integration-test	deploy artifaktu w środowisku integracyjnym
integration-test	uruchamia walidacje paczki
install	instaluje paczke w lokalnym repozytorium
deploy	kopiuje artifact na serwer

Każda faza zależy od poprzedniej. Wydając więc polecenie mvn compile Maven najpierw wykona fazę validate a następnie compile. No dobrze, w takim razie użyjmy pierwszy raz Mavena.

Po prawej stronie w IDE będziemy mieć zakładkę Maven Projects. Znajdziemy tam drzewa, gdzie korzej będzie nazywał się jak nasza aplikacja, czyli firstApp, zaś pod nim będzie gałąź Lifecycle oraz Plugins. Z listy cykli życia (Lifecycle) klikamy dwa razy lewym przyciskiem myszy na opcji clean a następnie analogicznie na opcji install. Jak zobaczymy - dużo będzie działo się w konsoli. Maven po kolei będzie wykonywał to co mu powiedzieliśmy. Z reguły pierwsze uruchomienie powoduje, że budowanie trwa dłużej gdyż Maven musi sobie pościągać niezbędne biblioteki. Skutek pracy pojawi się w katalogu target.

Koncepcja repozytoriów

Maven działa na zasadzie trzymania wybudowanych projektów w repozytoriach (wytworzonych w fazie install). Co to wszystko znaczy? Jeśli przyjrzymy się w logi fazy (install) zauważymy, że na końcu były logi w stylu:

...
...
[INFO] --- maven-install-plugin:2.4:install (default-install) @ firstApp ---
[INFO] Installing /home/acacko/IdeaProjects/firstApp/target/firstApp-1.0-SNAPSHOT.jar to /home/acacko/.m2/repository/pl/kodolamacz/firstApp/1.0-SNAPSHOT/firstApp-1.0-SNAPSHOT.jar
[INFO] Installing /home/acacko/IdeaProjects/firstApp/pom.xml to /home/acacko/.m2/repository/pl/kodolamacz/firstApp/1.0-SNAPSHOT/firstApp-1.0-SNAPSHOT.pom

Po co robi to Maven? Po co zbudowaną aplikację wrzuca od razu do repozytorium utworzonym w jednym z katalogów naszego komputera? Odpowiedź jest prosta: gdybyśmy chcieli za chwilę użyć jej w innym projekcie - Maven znajdzie ją sobie w repozytorium. Tak z resztą się często dzieje - gdy nasza aplikacja składa się z kilku podprojektów (tzw. modułów) - to Maven buduje najpierw te, które nie zależą od innych projektów, następnie wrzuca je do repozytorium a potem przechodzi do kolejnych projektów - a gdy któryś kolejny projekt potrzebuje kodu projektu już zbudowanego wcześniej - Maven po prostu sięga po jego kod do repo. Nieco później poznamy jeszcze większą zaletę tego podejścia - ale to jeszcze chwilka.

Plik pom.xml - sercem naszej aplikacji

To, że nasza aplikacja jest taka super - w zasadzie wynika tylko z jednej rzeczy - posiada ona plik pom.xml. Przyjrzyjmy się temu plikowi. Po kliknięciu na pom.xml wybieramy opcję surowego podglądu xml’a. Inne okienka są dla amatorów :)

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
<!-- to na górze jest zawsze takie samo, poniżej jest to co nas interesuje -->
    <groupId>pl.kodolamacz</groupId>
    <artifactId>firstApp</artifactId>
    <version>1.0-SNAPSHOT</version>

</project>

Ta część: „project xmlns=„http://…” jest jaka jest - nie musimy się przejmować, że nie wiemy co to jest. Taka jest konwencja i tyle. Bardziej interesują nas informacje, które są potem:

Tag	Wyjaśnienie
groupId	twórca (pl.edu.uksw)
artifactId	nazwa aplikacji (firstApp)
packaging	sposób pakowania aplikacji (jar, war, ear, pom). My znamy tylko jar
version	wersja naszej aplikacji
name	nazwa wyświetlana (opcjonalnie)
url	link do strony projektu (opcjonalnie)
dependencies	zależności od innych modułów (opcjonalnie)

To jest podstawowa wersja pom.xml, która zawiera minimalną ilość informacji i funkcjonalności. Przyjrzyjmy się schematowi całego tego pliku:

<project xmlns="http://maven.apache.org/POM/4.0.0"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
                      http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
 
  <!-- The Basics -->
  <groupId>...</groupId>
  <artifactId>...</artifactId>
  <version>...</version>
  <packaging>...</packaging>
  <dependencies>...</dependencies>
  <parent>...</parent>
  <dependencyManagement>...</dependencyManagement>
  <modules>...</modules>
  <properties>...</properties>
 
  <!-- Build Settings -->
  <build>...</build>
  <reporting>...</reporting>
 
  <!-- More Project Information -->
  <name>...</name>
  <description>...</description>
  <url>...</url>
  <inceptionYear>...</inceptionYear>
  <licenses>...</licenses>
  <organization>...</organization>
  <developers>...</developers>
  <contributors>...</contributors>
 
  <!-- Environment Settings -->
  <issueManagement>...</issueManagement>
  <ciManagement>...</ciManagement>
  <mailingLists>...</mailingLists>
  <scm>...</scm>
  <prerequisites>...</prerequisites>
  <repositories>...</repositories>
  <pluginRepositories>...</pluginRepositories>
  <distributionManagement>...</distributionManagement>
  <profiles>...</profiles>
</project>

Cóż - trochę tego jest. W Mavenie można zdziałać cuda - ale za długo by zmieścić je w jednym artykule. Skupimy się na tych najważniejszych.

Zależności

Co to jest zależność? Jest to projekt od którego zależy nasz projekt. Często jest tak, że gdy piszemy coś w projekcie np. aplikacji internetowej to zależeć ona będzie od projektu, który potrafi zapisywać dane do bazy danych. Dołączamy sobie więc w naszym projekcie zależność do projektu zarządzania bazą danych. Maven podłączy potrzebne kody do naszego projektu tak abyśmy mogli używać obiektów z tamtego projektu. Z resztą - może nawet za daleko szukamy - przecież każda biblioteka jakiej używamy w projekcie jest zależnością. Wszak nasz projekt jej potrzebuje do swojego działania. Niech teraz Maven martwi się aby gdzieś ją znaleźć i podłączyć do naszego projektu.

Wróćmy do naszego problemu katalogu ludzi po ich wieku. Pewnie zauważyliśmy, że jest to nieco męczące aby co chwila wrzucać do mapy nowy Set bo inaczej leciały nam NullPointery przy próbie wrzucenia pierwszej osoby o danym wieku. Kod wygląda amatorsko i można zrobić w nim pełno błędów. No więc co? Programista szuka pomocy w google: “Java Map with Multiple Values” i co? Otwieramy pierwszą stronę naszej ulubionej strony i co widzimy? Najwyżej ocenione jest nasze podejście - wrzucanie Set’ów do Mapy - przyznam, że podejście amatorskie - ale szybkie. Trzecie rozwiązanie jest przy użyciu biblioteki Apache Commons Collections 4 i obiektu MultiValueMap. Wygląda spoko więc użyjmy jej w naszym projekcie. Co należy zrobić? Wpisujemy sobie w google: “Apache Collections 4 maven” i wchodzimy w pierwszy link. Jest tam informacja, że Maven posiada tą bibliotekę w swoim repozytorium centralnym. Daje garść informacji o niej oraz to co najważniejsze - kod xml, aby przekopiować do pliku pom. Zróbmy to, pamiętając z ogólnego schematu, że zależności podaje się w bloku …:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>pl.kodolamacz</groupId>
    <artifactId>firstApp</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-collections4 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-collections4</artifactId>
            <version>4.0</version>
        </dependency>
    </dependencies>

</project>

IntelliJ IDEA powinna w tle ogarnąć, że zmienił się POM i spróbować zaciągnąć zależności poprzez uruchomienie w tle Mavena. Jeśli nie, należy jak poprzednio uruchomić opcję clean oraz install. W IDE pojawi się ona na liście z lewej strony w dziale “External Libraries”.

Podczas budowania aplikacji (Maven install) zauważymy, jak nasza biblioteka jest ściągana z Internetu… a następnie wrzucana do naszego repozytorium (~/.m2/repository/…). Jeśli za chwilę drugi raz będziemy budować - Maven tylko sprawdzi czy nic się nie zmieniło z tą wersją biblioteki odczytując sumę kontrolną - a następnie stwierdzi, że ma już tą bibliotekę zaciągniętą wcześniej - i użyje jej. Zajmie to wtedy dużo mniej czasu.

Pluginy

Maven posiada wiele pluginów, które potrafią rozszerzyć funkcjonalności Mavena. Począwszy od możliwości wskazywania wersji Javy jaką chcemy użyć a skończywszy na pluginach, które potrafią same połączyć się ze zdalnym serwerem i podmienić wersję aplikacji na tą właśnie zbudowaną i zrestartować maszynę.

Zacznijmy więc od tego najbardziej powszechnego - ustawiającego wersję Javy na taką jaką chcemy. Gdzie umieszczamy nasze pluginy? Nie widać ich w ogólnym schemacie xml. Nie widać ich bo umieszczamy je w sekcji :

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>pl.kodolamacz</groupId>
    <artifactId>firstApp</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-collections4 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-collections4</artifactId>
            <version>4.0</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.7.0</version>
                <configuration>
                    <source>10</source>
                    <target>10</target>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

Spróbuj zmienić wersję Javy np. na 1.3 i zobaczy czy skompiluje się kod. Jeśli IDE nie zauważy co się stało w POM to zawsze robimy clean potem install a następnie w zakładce Maven Projects → Reimport All Maven Projects (pierwsza ikonka na górze od lewej)

Pluginów jest mnóstwo i do wszystkiego. Zależnie co chcemy - pewnie już zostało to już zrobione. Część z nich już są zainstalowane domyślnie. Możemy je odnaleźć w zakładce Maven Projects → firstApp → Plugins.

Inne rzeczy, które powinieneś wiedzieć

Poza prostym budowaniem projektu i ściąganiem niezbędnych bibliotek, Maven potrafi znacznie więcej. Warto poznać takie zagadnienia jak choćby:

Używanie pliku settings.xml, który pozwala ustawić konfigurację dla wszystkich projektów - np. listę repozytoriów Mavena, hasła do GIT, jakieś wartości parametrów itp,
Tworzenie tzw. Parent POM’a, który daje możliwość zarządzać wieloma projektami, które „dziedziczą” właściwości po tym POMie. Można w jednym miejscu np. zmienić wersję biblioteki na nowszą - i wszystkie projekty będą miały ją zaktualizowaną bez potrzeby szukania jej po wszystkich POM innych projektów
Tworzenie tzw. modułów czyli wielu podprojektów składających się na jeden projekt. Np. często jest tak, że jeden podprojekt odpowiada za komunikację z bazą danych zaś inny podprojekt odpowiadający za aplikację desktop’ową go używa, oraz inny podprojekt odpowiadający za aplikację WEBową też go używa. Każdy z nich dodaje go do swojej zależności (dependency).
Używanie parametrów w projektach
Używanie profili Mavena
i wiele innych

Mimo że Maven jest jednym z najpopularniejszych rozwiązań w świecie JVM do zarządzania budowaniem projektów, ma swoją konkurencję. Jednym z ciekawszych tego typu projektów jest Gradle.

Wyzwanie Java #4: Algorytmy i struktury danych w języku Java - rozwiązanie

Thu, 10 May 2018 00:00:00 +0000

Czas na wyniki naszego kolejnego wyzwania. Tym razem mieliśmy do rozwiązania dwa zadania, jedno prostsze, drugie trudniejsze, wymagające od nas podstawowej znajomości struktur danych w języku Java i umiejętności pisania algorytmów z ich wykorzystaniem.

Zadanie nr 1

Zaczynamy od pierwszego zadania. Naszym celem było dla tablicy wejściowej input zawierającą liczby typu int zwrócić tablicę zawierającą ilość elementów ujemnych oraz sumę elementów dodatnich. Jeśli tablica była pusta lub null, wtedy należało zwrócić pustą tablicę.

To zadanie można było rozwiązać na kilka sposobów, jednym z nich jest:

package pl.kodolamacz;

public class JavaChallenge4Task1 {

    public static void main(String[] args) {
        int[] result = countAndSumElements(new int[]{1, 2, 3, 4, 5, -3, -2, -1});
        if (result.length == 2) {
            System.out.println("Liczb ujemnych: " + result[0]);
            System.out.println("Suma dodatnich: " + result[1]);
        }
    }

    public static int[] countAndSumElements(int[] input) {

        if (input == null || input.length == 0) return new int[0];

        var sum = 0;
        var count = 0;

        for (var element : input) {
            if (element > 0) sum += element;
            else if (element < 0) count++;
        }

        return new int[]{count, sum};
    }

}

Oprócz samej funkcji countAndSumElements dodaliśmy funkcję main pozwalającą nam w prosty sposób przetestować działanie naszej funkcji. W Javie można dużo sprawniej testować kod, jednak do tego wrócimy w innym poście.

Zadanie nr 2

W kolejnym zadaniu należało stworzyć algorytm sterujący pracą automatu z napojami. Zakładaliśmy, że automat przyjmuje monety 1zł, 2zł i 5zł. Puszka napoju kosztuje 1zł. Na starcie automat nie miał żadnych pieniędzy. Dla wskazanej listy wejściowej monet, należało zwrócić true lub false w zależności czy automat będzie w stanie zwrócić resztę. Każda moneta była wrzucana przez innego klienta.

Tutaj już trzeba napisać znacznie więcej kodu który realizował konkretny algorytm. Podstawowym problemem który można popełnić w tym zadaniu to zliczanie sumy pieniędzy w automacie, zamiast oddzielnie ilości monet każdego nominału. Niestety gdy ktoś wrzuci 5zł a automat będzie miał tylko w sobie monetę 5zł, to mimo że reszta 4zł jest mniejsza niż suma monet w środku, to nie da się wydać reszty. Z drugiej strony zliczając monety, wystarczy wiedzieć ile było monet 1zł i 2zł, gdyż monety 5zł nigdy nie są zwracane jako reszta, stąd można to pominąć.

To zadanie również można było rozwiązać na kilka sposobów, jednym z nich jest:

public class JavaChallenge4Task2 {

    public static void main(String[] args) {
        System.out.println(vendingMachine(List.of(1, 2, 1, 2, 5))); // dla pięciu zwracamy dwie dwójki
        System.out.println(vendingMachine(List.of(1, 2, 1, 1, 5))); // dla pięciu zwracamy dwójkę i dwie jedynki
        System.out.println(vendingMachine(List.of(1, 1, 1, 1, 5))); // dla pięciu zwracamy cztery jedynki

        System.out.println(vendingMachine(List.of(1, 2, 2, 5, 2))); // błąd, nie da się wydać przy drugiej dwójce bo w autmacie jest tylko moneta 2 zł
    }

    public static boolean vendingMachine(List<Integer> coins) {
        int count1Pln = 0;
        int count2Pln = 0;

        for (var coin : coins) {

            if (coin == 1) {
                count1Pln++;
            } else if (coin == 2) {
                if (count1Pln >= 1) {
                    count2Pln++; // zostaje 2zł, wydaje 1zł
                    count1Pln--;
                } else {
                    return false; // Jeśli ktoś wrzucił 2zł muszę mieć minimum jedną monetę 1zł by wydać resztę inaczej false
                }
            } else if (coin == 5) {
                // zostaje 5zł, wydajęmy dwie dwójki lub dwójkę i dwie jedynki lub cztery jedynki, dokładnie w tej kolejności
                if (count2Pln >= 2) {
                    count2Pln -= 2;
                } else if (count2Pln >= 1 && count1Pln >= 2) {
                    count2Pln--;
                    count1Pln -= 2;
                } else if (count1Pln >= 4) {
                    count1Pln -= 4;
                } else {
                    return false; // Nie udało mi się wydać żadnej kombinacji...
                }
            } else {
                return false; // ktoś wrzucił nieprawidłową monetę!!!
            }

        }
        return true;
    }

}

Wyzwanie Java #4: Algorytmy i struktury danych w języku Java

Sat, 05 May 2018 00:00:00 +0000

Programy operują na danych. Mogą one być wczytywane z plików, pochodzić z baz danych, z urządzeń i mierników czy być odbierane po sieci. Bez względu czy będziemy chcieli je tylko wyświetlić użytkownikowi, czy zrobić na nich jakąś zaawansowaną analizę matematyczną, zawsze będziemy potrzebowali w jakiś sposób je przechować w naszym programie. Mechanizm przechowywania w uporządkowany sposób informacji w naszym programie nazywamy strukturami danych. Na tych strukturach będą operować nasze algorytmy i bardzo często od wybranej struktury będzie zależeć wydajność danego algorytmu.

Algorytmy i struktury danych to podstawa na której opiera się cała dzisiejsza informatyka, dlatego na każdym kierunku studiów informatycznych jest przynajmniej jeden przedmiot poświęcony tym zagadnieniom. Powstało także mnóstwo książek na temat algorytmów i struktur danych, przy czym za jedną z czołowych pozycji uważana jest monografia “Sztuka programowania” napisana przez Donalda Knuth’a. Sam Bill Gates, założyciel firmy Microsoft, mawiał o tej książce: “Jeśli myślisz, że jesteś dobrym programistą (…) przeczytaj “Sztukę programowania” (…). Jeśli będziesz w stanie przeczytać całość, to zdecydowanie prześlij mi swoje CV”.

Zakres wiedzy do poznania dogłębnie algorytmów i struktur danych jest tak duży, że w tym poście opowiemy sobie tylko o podstawowych strukturach danych dostępnych w języku Java. Jako uzupełnienie polecam książkę Java 9 Data Structures and Algorithms, Debasish Ray Chawdhuri lub Data Structures and Algorithms in Java, 2nd Edition, Robert Lafore lub jakąkolwiek inną pozycję szeroko traktującą o tych zagadnieniach.

Tablice

Podstawową strukturą danych, dostępną w niemal każdym języku programowania są tablice. Tablice przechowują zbiór elementów tego samego typu z zachowaniem kolejności. Dostęp do dowolnego elementu w tablicy realizowany jest przez indeks (typu int) reprezentujący pozycję elementu w tablicy, zaczynając od zera. Oznacza to, że pierwszy element ma pozycję zero, drugi element pozycję jeden, trzeci dwa i tak dalej, aż do ostatniego elementu. Tablice też mają z góry określoną wielkość w momencie ich tworzenia, stąd od początku musimy wiedzieć ile elementów będziemy potrzebować przechować w naszej tablicy.

Tablicę deklarujemy podając jej typ, nazwę oraz używając nawiasów kwadratowych “[]”:

int[] a;
long[] b;
String[] c;

W powyższym przykładzie zadeklarowaliśmy trzy tablice typu int, long oraz String. Istnieje także możliwość zadeklarowania tablic tak jak to się robi w języku C/C++, czyli podając nawiasy “[]” obok nazwy, a nie typu:

int a[];
long b[];
String c[];

Żeby stworzyć tablicę, należy użyć słowa new poznanego w rozdziale poświęconym programowaniu obiektowemu. Oznacza to, że tablice w języku Java są obiektami.

int[] a = new int[100];
long b[] = new long[10];
String[] c = new String[5];

Podczas tworzenia tablic wymagane jest podanie długości, czyli liczby elementów, które będzie przechowywać. Podczas tej operacji tworzona jest sama tablica, jednak jest ona pusta w środku.

W celu wypełnienia tablicy, trzeba odwołać się do jej poszczególnych pozycji za pomocą indeksu (pamiętajmy o numeracji od zera):

a[0] = 5;
a[10] = 245;
a[34] = -27;

c[0] = "Ala";
c[2] = "ma";
c[4] = "kota";

Analogicznie możemy za pomocą indeksu dostać się do zawartości jakiegoś elementu w tablicy:

System.out.println("Element nr 0 z tablicy c ma wartość: " + c[0]);

Do stworzenia i odczytania elementów w tablicy możemy także użyć pętli, np. for:

for (var i = 0; i < 100; i++) {
    a[i] = i;
}

for (var i = 0; i < 100; i++) {
    System.out.println(a[i]);
}

W powyższym przykładzie nasza tablica została wypełniona liczbą taką jak numer indeksu tej liczby, czyli pozycji w tablicy a następnie wszystkie elementy zostały wyświetlone. Podczas inicjalizacji tablicy wszystkie typy proste jak int, long, boolean są inicjalizowane (uzupełniane) ich domyślnymi wartościami, czyli w przypadku int będzie to zero, zaś boolean wartość false. W przypadku typów złożonych, czyli obiektów, domyślnie dostajemy wartość null, co można zauważyć na poniższym przykładzie:

c[0] = "Ala";
c[2] = "ma";
c[4] = "kota";

for (var i = 0; i < 5; i++) {
    System.out.println(c[i]);
}

wynik programu powyżej:

Ala
null
ma
null
kota

Niestety, w powyższych przykładach kodu, zawsze musieliśmy wiedzieć jaką dana tablica ma długość, by wskazać to w pętli for. W zamian można użyć właściwości lenght tablicy:

for (var i = 0; i < c.length; i++) {
    System.out.println(c[i]);
}

Gdy korzystamy ze wszystkich elementów tablicy, o wiele wygodniejsze jest użycie nowej wersji pętli form, tak zwany foreach, czyli dla każdego elementu:

for (var element : c) {
    System.out.println(element);
}

Jedyne co tutaj musimy wskazać to nazwę zmiennej, w której będą umieszczane kolejne elementy tablicy. W naszym przypadku jest to zmienna “element”.

Jeśli z góry wiemy jakie elementy będziemy przechowywać w naszej tablicy, możemy użyć do jej stworzenia uproszczonego zapisu:

String[] names = {"Kasia", "Tomek", "Patryk"};

Zauważmy, że w powyższym przykładzie nie musieliśmy podawać długości tablicy, będzie ona równa liczbie elementów wskazanych przy jej tworzeniu, czyli w naszym przypadku będzie równa trzy.

Dla osób dociekliwych:

Tablice mogą również być wielowymiarowe. Można to rozumieć jako tablicę, która zawiera w sobie inne tablice. Można także tablice dwuwymiarową wyobrażać sobie jako szachownicę, zaś trójwymiarową jako kostkę rubika.

Poniżej przykład stworzenia i wyświetlenia tablicy dwuwymiarowej 3x3 liczb typu int:

int[][] tab = new int[3][3];

for (int i = 0; i < tab.length; i++) {
    for (int k = 0; k < tab[i].length; k++) {
        tab[i][k] = i + k;
    }
}

for (int i = 0; i < tab.length; i++) {
    for (int k = 0; k < tab[i].length; k++) {
        System.out.println("tab[" + i + "][" + k + "] = " + tab[i][k]);
    }
}

Kolekcje

Oprócz tablic, w języku Java mamy dostęp do bardziej zaawansowanych struktur danych, zwanych kolekcjami. Zbiór kolekcji dzieli sią na interfejsy, implementacje i algorytmy, które możemy wykonywać na kolekcjach. Interfejs opisuje nam daną kolekcję, inaczej kontener, czyli mówi z jakich metod możemy skorzystać w danej kolekcji. Implementacja to klasa, która realizuje dane operacje, jednak na różne sposoby. To trochę tak, jakby w tym samym samochodzie zamontować raz silnik benzynowy, a raz silnik Diesla. Silnik to nasz interfejs, zaś silnik benzynowy i silnik wysokoprężny to już jego dwie implementacje, które robią to samo - napędzają nasz samochód, ale w zupełnie inny sposób.

W zależności od wymagań naszego algorytmu, możemy wybrać zupełnie inną kolekcję lub jej implementację, by nasz program był jak najwydajniejszy. Dlatego gruntowna wiedza o algorytmach i strukturach danych bywa tak istotna przy tworzeniu oprogramowania, zwłaszcza obliczeniowego.

Poniższy diagram przedstawia w uproszczeniu dostępne interfejsy kolekcji w Javie:

List

Kolekcje typu List (lista) są bardzo podobne do tablic. Tak samo jak one są zbiorem przechowującym elementy z zachowaniem ich kolejności. Mogą także przechowywać duplikaty. Jednak w przeciwieństwie do tablic, listy są dynamiczne, to znaczy, że w trakcie działania programu możemy dodawać nowe elementy i nie musimy podczas tworzenia listy podawać jej maksymalnej długości. Dwiema popularnymi implementacjami List są ArrayList i LinkedList. Pierwsza implementacja opiera się o tablicę (stąd nazwa ArrayList), druga jest tak zwaną listą powiązaną, gdzie elementy są ze sobą połączone niczym wagoniki w kolejce. W większości przypadków lista ArraList będzie wydajniejsza, stąd jeśli nie wiecie jaką wybrać, jest ona zdecydowanie bezpieczniejszym wyborem. Korzystanie z LinkedList w nieprawidłowy sposób często bywa źródłem problemów wydajnościowych w programach!

Poniżej przykład stworzenia listy i włożenia do niej elementów:

List<Integer> list = new ArrayList<>();
list.add(5);
list.add(4745);
list.add(-87);

Służy do tego metoda add która dodaje nowy element (u nas liczby 5, 4745 i -87) na końcu listy. Do listy możemy dodać dowolną inną kolekcję za pomocą metody addAll:

List<Integer> list = new ArrayList<>();
list.add(5);
list.add(4745);
list.add(-87);

List<Integer> list2 = new LinkedList<>();
list2.add(35);
list2.add(-14);

list.addAll(list2);

Nasze elementy możemy wkładać na dowolną pozycję, nie tylko ostatnie miejsce, wtedy należy podać w metodzie add lub addAll pozycję gdzie mają trafić nowe elementy:

List<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);

List<Integer> list2 = new LinkedList<>();
list2.add(4);
list2.add(0, 5);  // liczba 5 trafia na początek listy nr 2

list.addAll(2, list2); // do listy 1 dodaję listę 2, od trzeciej pozycji (czyli po kolei: 1,2,5,4,3)

Do poszczególnych elementów listy można dostać się, podobnie jak w tablicach, za pomocą pętli foreach:

for (var element : list) {
    System.out.println(element);
}

lub bezpośrednio do dowolnego elementu za pomocą indeksu:

System.out.println(list.get(0));
System.out.println(list.get(3));

Interfejs List ma wiele przydatnych metod, w tym takie metody jak:

add i addAll - dodawanie elementu/-ów
clear - usunięcie wszystkich elementów
remove i removeAll - usunięcie elementu/-ów
isEmpty - sprawdzenie czy lista jest pusta
size - sprawdzenie wielkości
set - zamiana elementu na inny element
sort - posortowanie listy
toArray - zamiana na tablicę
indexOf - zwrócenie pozycji wskazanego elementu

Większość z powyższych metod pochodzi z interfejsu Collection, co oznacza, że jest dostępna dla wszystkich kolekcji zgodnie z diagramem przedstawionym wcześniej.

Poniżej przykład użycia części z powyższych metod:

List<Integer> collection1 = new ArrayList<>();
List<Integer> collection2 = new LinkedList<>();

collection1.add(1);  // dodawanie elementów
collection1.add(2);
collection1.add(3);

collection2.add(4);
collection2.add(0, 5); // dodanie elementu na początku kolekcji nr. 2

collection1.addAll(2, collection2); // łączenie kolekcji, druga kolekcja zacznie się po drugim elemencie

System.out.println("Elementy: ");
for (var element : collection1) {
    System.out.println(element);
}

System.out.println("Pozycja liczby 3 to: " + collection1.indexOf(3)); // pozycje w kolekcjach numerowane są także od zera!!!
collection1.remove(2); // usunięcie trzeciego elementu
System.out.println("Pozycja liczby 3 to: " + collection1.indexOf(3));

collection1.set(0, 10); // zamieniam pierwszy element na 10
System.out.println("Pierwszy element kolekcji: " + collection1.get(0));

collection1.clear();
System.out.println("Liczba elementów: " + collection1.size());

Set

Kolejną i bardzo często używaną w praktyce kolekcją jest Set (zbiór). W przeciwieństwie do list, zbiory nie pozwalają na dodawanie duplikatów.

Wyróżniamy aż trzy podstawowe implementacje:

HashSet - najpopularniejszy i zarazem najwydajniejszy, jednak nie zachowuje żadnego porządku (kolejności), co oznacza, że elementy będą zwracane w losowej kolejności, jest oparty o tablice mieszające
TreeSet - wolniejszy od HashSet, lecz zachowujący kolejność elementów ze względu na ich wartość (sortowanie), oparty na algorytmie drzewa czerwono czarnego, od którego pochodzi jego przedrostek “tree”
LinkedHashSet - podobnie do HashSet bazuje na tablicach mieszających, jednak z tą różnicą, że dzięki zastosowaniu dodatkowo listy powiązanej (linked list), zachowuje kolejność w jakiej elementy są dodawane do kolekcji

Poniżej przykładowy kod z użyciem dwóch implementacji interfejsu Set:

Set<Integer> collection1 = new TreeSet<>();
Set<Integer> collection2 = new HashSet<>();

collection1.add(1);  // dodawanie elementów
collection1.add(2);
collection1.add(3);

collection2.add(5);
collection2.add(4);

collection1.addAll( collection2); // łączenie kolekcji

System.out.println("Elementy: ");
for (var element : collection1) {
    System.out.println(element);
}

System.out.println("Liczba elementów: " + collection1.size());
collection1.remove(2); // usunięcie liczby dwa!
System.out.println("Liczba elementów: " + collection1.size());

collection1.clear();
System.out.println("Liczba elementów: " + collection1.size());

Map

Trzecią i zarazem niezwykle popularną kolekcją stosowaną przez programistów języka Java jest Map (mapa lub słownik). Kolekcja ta służy do przechowywania par klucz - wartość. Dlatego na diagramie kolekcji, nie są zależne od interfejsu Collection.

Mamy dostępne trzy podstawowe implementacje interfejsu Map:

HashMap - analogiczna do HashSet
TreeMap - analogiczna do TreeSet
LinkedHashMap - analogiczna do LinkedHashSet

Jak widać słowniki (map) są zbudowane i zachowują się jak zbiory (set), z tą różnicą, że operują na elementach będących parami.

Poniżej przykład użycia dwóch implementacji Map:

Map<Integer, String> collection1 = new TreeMap<>();
Map<Integer, String> collection2 = new HashMap<>();

collection1.put(1, "jeden");  // dodawanie elementów
collection1.put(2, "dwa");
collection1.put(3, "trzy");

collection2.put(5, "pięć");
collection2.put(4, "cztery");

collection1.putAll(collection2); // łączenie kolekcji

System.out.println("Klucze: ");
for (var key : collection1.keySet()) {
    System.out.println(key);
}

System.out.println("Wartości: ");
for (var value : collection1.values()) {
    System.out.println(value);
}

System.out.println("Pary: ");
for (var entry : collection1.entrySet()) {
    System.out.println(entry.getKey() + " -> " + entry.getValue());
}

System.out.println("Liczba elementów: " + collection1.size());
collection1.remove(2); // usunięcie pary pod kluczem dwa!
System.out.println("Liczba elementów: " + collection1.size());

collection1.clear();
System.out.println("Liczba elementów: " + collection1.size());

W przeciwieństwie do poprzednich kolekcji, dodawanie nowych elementów następuje dzięki metodom put i putAll, a nie add i addAll.

Znacząco też zmieniła się postać pętli foreach. W przypadku map, możemy iterować się po zbiorze kluczy (keySet), zbiorze wartości (values) oraz po zbiorze par (entrySet), gdzie każda para składa się z klucza i wartości.

Przedstawiona wiedza o tablicach i kolekcjach to niestety tylko wierzchołek góry lodowej, zwanej algorytmami i strukturami danych, dlatego zachęcamy wszystkich do rozszerzenia tej wiedzy o stosowne lektury. Java od wersji ósmej ma także dostępny bardzo rozbudowany mechanizm operacji na kolekcjach zwany strumieniami (streams), ale jemu poświęcimy oddzielne wyzwanie.

Wyzwanie

Czas na nasze wyzwanie. Tym razem rozbijemy je na dwie części, pierwszą z zastosowaniem samych struktur danych i drugą, znacznie trudniejszą, gdzie trzeba będzie wymyślić algorytm operujący na tych strukturach.

Zadanie nr 1

Dla tablicy wejściowej input zawierającą liczby typu int zwrócić tablicę zawierającą ilość elementów ujemnych oraz sumę elementów dodatnich. Jeśli tablica będzie pusta lub null, wtedy należy zwrócić pustą tablicę.

public static int[] countAndSumElements(int[] input) {
    // TODO tutaj kod
}

Przykład: Dla wejścia: input int[] {1, 2, 3, 4, 5, -3, -2, -1} program powinien zwrócić: int[] {3, 15}, czyli 3 liczby ujemne i suma liczb dodatnich równa 15.

Zadanie nr 2

Należy stworzyć algorytm sterujący pracą automatu z napojami. Zakładamy, że automat przyjmuje monety 1zł, 2zł i 5zł. Puszka napoju kosztuje 1zł. Na starcie automat nie ma żadnych pieniędzy.

Dla wskazanej listy wejściowej monet, należy zwrócić true lub false w zależności czy automat będzie w stanie zwrócić resztę. Każda moneta jest wrzucana przez innego klienta.

public static boolean vendingMachine(List<Integer> coins) {
    // TODO tutaj kod
}

Przykład: Dla monet: List coins = List.of(1, 2, 1, 1, 5) program zwróci wartość true, zaś dla monet: List coins = List.of(1, 2, 2, 5, 2) program powinien zwrócić wartość false, gdyż już dla drugiej monety 2zł nie będzie możliwości zwrócenia reszty kupującemu.

Wyzwanie Java #3: Programowanie obiektowe - rozwiązanie

Fri, 04 May 2018 00:00:00 +0000

Czas na rozwiązanie naszego kolejnego wyzwania. Tym razem podnieśliśmy poprzeczkę znacznie wyżej, dlatego jeśli mieliście jakieś problemy, zachęcamy potraktowanie tego rozwiązania jako wskazówki i spróbowania samodzielnego rozwiązania zadania.

W trzecim wyzwaniu poprosiliśmy Was o stworzenie kalkulatora, który będzie pracował na własnym typie (klasie) Fraction reprezentującym ułamek. Problem jaki mogliśmy spotkać w poprzednim rozwiązaniu, to operacje typu 2 / 3 były rzutowane na typ double i przez to zaokrąglane do postaci 0.66(6), co będzie skutkować błędami obliczeń.

By wyjaśnić lepiej zadanie, a tym samym rozwiać wątpliwości związane z programowaniem obiektowym, zadanie będzie rozwiązane krok po kroku.

Rozwiązanie

Zaczynamy od stworzenia klasy Fraction z trzema polami wymienionymi w zadaniu, czyli licznika, mianownika i części całkowitej:

package pl.kodolamacz.math;

public class Fraction {

    private int fractionInteger;
    private int numerator;
    private int denominator;

}

Żeby móc stworzyć ten obiekt wraz z polami, dodamy konstruktor, czyli specjalną “metodę” tworzącą obiekty:

package pl.kodolamacz.math;

public class Fraction {

    private int fractionInteger;
    private int numerator;
    private int denominator;

    public Fraction(int fractionInteger, int numerator, int denominator) {
        this.fractionInteger = fractionInteger;
        this.numerator = numerator;
        this.denominator = denominator;
    }

}

Na razie idzie prosto. Jednak klasa jeszcze nic nie potrafi, pola są prywatne (hermetyzacja), więc tworząc taką klasę nie mamy nawet do nich dostępu… Dlatego stwórzmy sobie dodatkowo funkcję która zwraca nam ułamek w postaci dziesiętnej, czyli po prostu typ double. Dostajemy zatem taki kod:

package pl.kodolamacz.math;

public class Fraction {

    private int fractionInteger;
    private int numerator;
    private int denominator;

    public Fraction(int fractionInteger, int numerator, int denominator) {
        this.fractionInteger = fractionInteger;
        this.numerator = numerator;
        this.denominator = denominator;
    }

    public double getFractionAsDecimal() {
        return fractionInteger + (double) numerator / denominator;
    }

}

W powyższym kodzie trudność może sprawić konieczność rzutowania, czyli wymuszenia by liczba numerator będąca typem int była jednak potraktowana jako double. Gdybyśmy tego nie zrobili, wynik działania zostałby “obcięty” do części całkowitej, w końcu typ int jest typem całkowitym. Sam wynik byłby zwrócony jako double, tak robi to nasza metoda, jednak wtedy będzie już “za późno”, końcówka zostanie ucięta wcześniej (zgodnie z kolejnością wykonywania obliczeń).

Teraz możemy pójść dalej i zaimplementować podstawowe operacje matematyczne na ułamkach, czyli dodawanie, odejmowanie, mnożenie i dzielenie.

Nasza klasa zaczyna wyglądać tak:

package pl.kodolamacz.math;

public class Fraction {

    private int fractionInteger;
    private int numerator;
    private int denominator;

    public Fraction(int fractionInteger, int numerator, int denominator) {
        this.fractionInteger = fractionInteger;
        this.numerator = numerator;
        this.denominator = denominator;
    }

    public Fraction(int numerator, int denominator) {
        if (numerator == denominator) { // gdy licznik i mianownik równe, wynik to liczba 1
            this.fractionInteger = 1;
            this.numerator = 0;
            this.denominator = 1;
        } else if (numerator > denominator) { // ułamek niewłaściwy, wyciągamy część całkowitą
            this.fractionInteger = numerator / denominator;
            this.numerator = numerator % denominator;
            this.denominator = denominator;
        } else { // ułamek właściwy
            this.fractionInteger = 0;
            this.numerator = numerator;
            this.denominator = denominator;
        }
    }

    public double getFractionAsDecimal() {
        return fractionInteger + (double) numerator / denominator;
    }

    public Fraction add(Fraction fraction) {
        int n1 = this.numerator + this.fractionInteger * this.denominator;
        int d1 = this.denominator;
        int n2 = fraction.numerator + fraction.fractionInteger * fraction.denominator;
        int d2 = fraction.denominator;
        return new Fraction(n1 * d2 + n2 * d1, d1 * d2);
    }

    public Fraction subtract(Fraction fraction) {
        int n1 = this.numerator + this.fractionInteger * this.denominator;
        int d1 = this.denominator;
        int n2 = fraction.numerator + fraction.fractionInteger * fraction.denominator;
        int d2 = fraction.denominator;
        return new Fraction(n1 * d2 - n2 * d1, d1 * d2);
    }

    public Fraction multiply(Fraction fraction) {
        int n1 = this.numerator + this.fractionInteger * this.denominator;
        int d1 = this.denominator;
        int n2 = fraction.numerator + fraction.fractionInteger * fraction.denominator;
        int d2 = fraction.denominator;
        return new Fraction(n1 * n2, d1 * d2);
    }

    public Fraction divide(Fraction fraction) {
        int n1 = this.numerator + this.fractionInteger * this.denominator;
        int d1 = this.denominator;
        int n2 = fraction.numerator + fraction.fractionInteger * fraction.denominator;
        int d2 = fraction.denominator;
        return new Fraction(n1 * d2, d1 * n2);
    }

}

Dla ułatwienia czytelności działań matematycznych, zostały użyte dodatkowe zmienne n1, d1, n2, d2. Należy zauważyć, że obok czterech metod odpowiadających za podstawowe operacje matematyczne został dodany nowy konstruktor który przyjmuje jedynie licznik i mianownik i w razie potrzeby wyciąga część całkowitą gdy ułamek jest niewłaściwy, tworzymy wtedy tak zwaną liczbę mieszaną.

Jesteśmy już praktycznie “w domu”. Taka postać klasy Fraction spełnia nasze podstawowe wymagania, czyli możliwość pracy na ułamkach. Jednak pokusimy się tutaj o dodanie czegoś bardziej zaawansowanego, mianowicie skracanie ułamków. Powyższy kod potrafi nam wyprodukować wynik w postaci 10/8, więc warto by było rozszerzyć klasę o algorytm skracający ułamek do postaci 5/4. By skrócić ułamek, potrzebujemy wyliczyć największy wspólny dzielnik (NWD) (ang. GCD - Greatest Common Divisor). Tutaj jednak zaczynają się schody, bo nie jest to wcale tak trywialne zadanie, by go obliczyć. Można oczywiście poszukiwać NWD iterując się w pętli po wszystkich możliwych liczbach z zakresu od zera do mniejszej z nich, dzielić obydwie i sprawdzać czy reszta z dzielenia dla obydwu jest zerowa, ale nie będzie to zbyt optymalne. Euklides odkrył, że największy wspólny dzielnik dwóch liczb, dzieli także ich różnicę, dlatego wystarczy, że dopóki dwie liczby są identyczne, odejmujemy od większej mniejszą. Gdy liczby staną się równe, dowolna z nich to nasz NWD.

Nasza klasa po przeróbce może wyglądać tak:

package pl.kodolamacz.math;

public class Fraction {

    private int fractionInteger;
    private int numerator;
    private int denominator;

    public Fraction(int fractionInteger, int numerator, int denominator) {
        // UWAGA, ten kod nie zabezpiecza nas przed mianownikiem równym zero!

        int gcd = gcd(numerator, denominator);

        // skracanie ułamka
        numerator = numerator / gcd;
        denominator = denominator / gcd;

        this.fractionInteger = fractionInteger;
        this.numerator = numerator;
        this.denominator = denominator;
    }

    public Fraction(int numerator, int denominator) {
        // UWAGA, ten kod nie zabezpiecza nas przed mianownikiem równym zero!

        int gcd = gcd(numerator, denominator);

        // skracanie ułamka
        numerator = numerator / gcd;
        denominator = denominator / gcd;

        if (numerator == denominator) { // gdy licznik i mianownik równe, wynik to liczba 1
            this.fractionInteger = 1;
            this.numerator = 0;
            this.denominator = 1;
        } else if (numerator > denominator) { // ułamek niewłaściwy, wyciągamy część całkowitą
            this.fractionInteger = numerator / denominator;
            this.numerator = numerator % denominator;
            this.denominator = denominator;
        } else { // ułamek właściwy
            this.fractionInteger = 0;
            this.numerator = numerator;
            this.denominator = denominator;
        }
    }

    public double getFractionAsDecimal() {
        return fractionInteger + (double) numerator / denominator;
    }

    public Fraction add(Fraction fraction) {
        int n1 = this.numerator + this.fractionInteger * this.denominator;
        int d1 = this.denominator;
        int n2 = fraction.numerator + fraction.fractionInteger * fraction.denominator;
        int d2 = fraction.denominator;
        return new Fraction(n1 * d2 + n2 * d1, d1 * d2);
    }

    public Fraction subtract(Fraction fraction) {
        int n1 = this.numerator + this.fractionInteger * this.denominator;
        int d1 = this.denominator;
        int n2 = fraction.numerator + fraction.fractionInteger * fraction.denominator;
        int d2 = fraction.denominator;
        return new Fraction(n1 * d2 - n2 * d1, d1 * d2);
    }

    public Fraction multiply(Fraction fraction) {
        int n1 = this.numerator + this.fractionInteger * this.denominator;
        int d1 = this.denominator;
        int n2 = fraction.numerator + fraction.fractionInteger * fraction.denominator;
        int d2 = fraction.denominator;
        return new Fraction(n1 * n2, d1 * d2);
    }

    public Fraction divide(Fraction fraction) {
        int n1 = this.numerator + this.fractionInteger * this.denominator;
        int d1 = this.denominator;
        int n2 = fraction.numerator + fraction.fractionInteger * fraction.denominator;
        int d2 = fraction.denominator;
        return new Fraction(n1 * d2, d1 * n2);
    }

    /**
     * Największy wspólny dzielnik
     */
    public static int gcd(int a, int b) {
        if (a < 0) a = -a; // zmieniamy na wartości dodatnie
        if (b < 0) b = -b;

        while (a != b)
            if (a > b) a -= b;
            else b -= a;

        return a;
    }

}

Skracanie zostało użyte w obydwu konstruktorach.

Powyższą modyfikacja wymagała większej wiedzy matematycznej, dlatego potraktujmy to jako wersję z gwiazdką.

To wszystko co należało wykonać w klasie Fraction. Zostało już jedynie napisanie samego kalkulatora, czyli klasy z metodą main. Ten kod stworzyliśmy już w poprzednim wyzwaniu, teraz jedynie go zmodyfikujemy o użycie klasy Fraction:

package pl.kodolamacz.calc;

import pl.kodolamacz.math.Fraction;

import java.util.Scanner;

public class FractionCalculator {

    public static void main(String[] args) {

        var scanner = new Scanner(System.in);

        System.out.println("Proszę podaj w oddzielnych linijkach jakąś liczbę, operację matematyczną +,-,*,/ a następnie kolejną liczbę:");

        String runAgain;
        do {

            var numerator = scanner.nextInt();
            scanner.next();
            var denominator = scanner.nextInt();
            scanner.nextLine();
            var x = new Fraction(numerator, denominator);

            var operation = scanner.nextLine();

            numerator = scanner.nextInt();
            scanner.next();
            denominator = scanner.nextInt();
            scanner.nextLine();
            var y = new Fraction(numerator, denominator);

            Fraction result;
            if (operation.equals("+")) {
                result = x.add(y);
            } else if (operation.equals("-")) {
                result = x.subtract(y);
            } else if (operation.equals("*")) {
                result = x.multiply(y);
            } else if (operation.equals("/")) {
                result = x.divide(y);
            } else {
                System.out.println("Nieznana operacja!");
                result = new Fraction(0);
            }
            System.out.println("Twój wynik to: " + result.getFractionAsString());

            System.out.println("Chcesz wykonać kolejne działanie? Wpisz literę t lub n.");
            runAgain = scanner.nextLine();

        } while (runAgain.equals("t"));

        scanner.close();
    }

}

W powyższym kodzie zostało przyjęte, że użytkownik podaje liczby w postaci: licznik / mianownik. Aby ułatwić sobie napisanie powyższego kodu, dodaliśmy dodatkowo nowy konstruktor przyjmujący tylko część całkowitą oraz metodę getFractionAsString zwracającą ułamek jako String do wyświetlenia.

Ostateczna wersja klasy Fraction wygląda tak:

package pl.kodolamacz.math;

public class Fraction {

    private int fractionInteger;
    private int numerator;
    private int denominator;

    public Fraction(int value) {
        fractionInteger = value;
        numerator = 0;
        denominator = 1;
    }

    public Fraction(int fractionInteger, int numerator, int denominator) {
        // UWAGA, ten kod nie zabezpiecza nas przed mianownikiem równym zero!

        int gcd = gcd(numerator, denominator);

        // skracanie ułamka
        numerator = numerator / gcd;
        denominator = denominator / gcd;

        this.fractionInteger = fractionInteger;
        this.numerator = numerator;
        this.denominator = denominator;
    }

    public Fraction(int numerator, int denominator) {
        // UWAGA, ten kod nie zabezpiecza nas przed mianownikiem równym zero!

        int gcd = gcd(numerator, denominator);

        // skracanie ułamka
        numerator = numerator / gcd;
        denominator = denominator / gcd;

        if (numerator == denominator) { // gdy licznik i mianownik równe, wynik to liczba 1
            this.fractionInteger = 1;
            this.numerator = 0;
            this.denominator = 1;
        } else if (numerator > denominator) { // ułamek niewłaściwy, wyciągamy część całkowitą
            this.fractionInteger = numerator / denominator;
            this.numerator = numerator % denominator;
            this.denominator = denominator;
        } else { // ułamek właściwy
            this.fractionInteger = 0;
            this.numerator = numerator;
            this.denominator = denominator;
        }
    }

    public double getFractionAsDecimal() {
        return fractionInteger + (double) numerator / denominator;
    }

    public String getFractionAsString() {
        if (denominator == 1) { // jeśli mianownik równy 1, to w naszej klasie powinniśmy mieć liczbę całkowitą
            return String.valueOf(fractionInteger);
        } else if (fractionInteger == 0) { // jeśli nie ma części całkowitej zwracamy sam ułamek
            return numerator + "/" + denominator;
        } else { // jeśli jest część całkowita to zwracamy jako liczbę mieszaną
            return fractionInteger + " " + numerator + "/" + denominator;
        }
    }

    public Fraction add(Fraction fraction) {
        int n1 = this.numerator + this.fractionInteger * this.denominator;
        int d1 = this.denominator;
        int n2 = fraction.numerator + fraction.fractionInteger * fraction.denominator;
        int d2 = fraction.denominator;
        return new Fraction(n1 * d2 + n2 * d1, d1 * d2);
    }

    public Fraction subtract(Fraction fraction) {
        int n1 = this.numerator + this.fractionInteger * this.denominator;
        int d1 = this.denominator;
        int n2 = fraction.numerator + fraction.fractionInteger * fraction.denominator;
        int d2 = fraction.denominator;
        return new Fraction(n1 * d2 - n2 * d1, d1 * d2);
    }

    public Fraction multiply(Fraction fraction) {
        int n1 = this.numerator + this.fractionInteger * this.denominator;
        int d1 = this.denominator;
        int n2 = fraction.numerator + fraction.fractionInteger * fraction.denominator;
        int d2 = fraction.denominator;
        return new Fraction(n1 * n2, d1 * d2);
    }

    public Fraction divide(Fraction fraction) {
        int n1 = this.numerator + this.fractionInteger * this.denominator;
        int d1 = this.denominator;
        int n2 = fraction.numerator + fraction.fractionInteger * fraction.denominator;
        int d2 = fraction.denominator;
        return new Fraction(n1 * d2, d1 * n2);
    }

    /**
     * Największy wspólny dzielnik
     */
    public static int gcd(int a, int b) {
        if (a < 0) a = -a; // zmieniamy na wartości dodatnie
        if (b < 0) b = -b;

        while (a != b)
            if (a > b) a -= b;
            else b -= a;

        return a;
    }

}

zaś samo wykonanie programu:

Proszę podaj w oddzielnych linijkach jakąś liczbę, operację matematyczną +,-,*,/ a następnie kolejną liczbę:
1 / 2
+
3 / 4
Twój wynik to: 1 1/4
Chcesz wykonać kolejne działanie? Wpisz literę t lub n.
t
5 / 4
+
7 / 8
Twój wynik to: 2 1/8
Chcesz wykonać kolejne działanie? Wpisz literę t lub n.
n

Process finished with exit code 0

Czy można to zrobić jeszcze lepiej?

Podobnie jak poprzednio, warto by było w przyszłości rozszerzyć ten program o lepszą obsługę błędów w przypadku sytuacji wyjątkowych, takich jak np. dzielenie przez zero. O walidacji i obsłudze błędów w Javie wspomnimy jednak w innym wyzwaniu, dlatego teraz jeszcze to pomijamy. Jeśli byście chcieli zobaczyć, jak wygląda taka klasa po uwzględnieniu wszystkich sytuacji wyjątkowych z zastosowaniem bardziej zaawansowanych algorytmów niż powyższe, polecam spojrzeć na kod źródłowy klasy Fraction z otwarto źródłowej biblioteki Apache Commons.

Java od środka, czyli jak to wszystko działa?

Thu, 03 May 2018 00:00:00 +0000

W poprzednich wyzwaniach dowiedzieliśmy się, że nasze programy pisane w języku Java działają dzięki wirtualnej maszynie Java. Dowiedzieliśmy się także, że na wirtualnej maszynie Java można uruchamiać programy napisane w innych językach programowania jak np. Scala, Groovy czy Kotlin. Dzisiejszy post będzie poświęcony temu, jak to wszystko działa. Nie jest to wiedza niezbędna, by zacząć swoją przygodę z programowaniem, wręcz przeciwnie, wielu programistów potrafi polec na rozmowie kwalifikacyjnej o pytania dotyczące maszyny wirtualnej, jednak do biegłego posługiwania się językami ze świata maszyny wirtualnej Java, warto dowiedzieć się co mamy pod przysłowiową maską.

Maszyna wirtualna Java

Wszystko zaczyna się od Wirtualnej Maszyny Java. To ona stoi za wielkim sukcesem całej platformy Java. To także ona jako pierwsza musi być zainstalowana w naszym komputerze by móc uruchomić jakiekolwiek aplikacje napisane w języku Java.

W praktyce JVM jest to jakiś program instalowany tak jak inne programy w naszym komputerze. Oznacza to, że wirtualna maszyna pracuje w danym systemie operacyjnym i musi być z nim zgodna, stąd na stronie Oracle można ją ściągnąć dla takich systemów jak Windows, Linux, macOS czy Solaris. Także Android (Dalvik) i inne systemy mobilne lub wbudowane mają swoją wersję maszyny wirtualnej. Możemy nawet uruchamiać programy w Javie na Lego Mindstorms.

Jest także wiele implementacji JVM. Najpopularniejsza jest oczywiście wirtualna maszyna tworzona przez firmę Oracle, zaś wcześniej przez firmę Sun, tak zwana Oracle HotSpot. Firma Oracle przejęła też projekt innej maszyny wirtualnej produkowanej przez BEA Systems, czyli JRockit. Projekt ten został jednak zamknięty, zaś część jego kodu została przeniesiona do maszyny wirtualnej Oracle oraz do projektu OpenJDK. Jest to otwarto źródłowa implementacja maszyny wirtualnej zainicjowana jeszcze przez firmę Sun. Jest to domyślna implementacja stosowana w systemach Linux oraz obrazach Docker’a czy innych systemów konteneryzacji. Projekt OpenJDK jest także prowadzony przez firmę Oracle przy współpracy z innymi firmami i programistami z całego świata. Tak naprawdę, obecna wersja maszyny wirtualnej Java dostępnej na stronie jest hybrydą dwóch starszych wersji przejętych przez firmę Oracle (HotSpot i JRockit) oraz w dużej mierze bazuje na OpenJDK. Plan firmy Oracle, zapowiedziany na filmie, jest taki, by OpenJDK była wersją krótkoterminową, przeznaczoną dla zwykłych użytkowników, developerów, zaś Oracle JDK ma być wersję długoterminową, dla firm i instytucji, którym zależy na stabilności przed długi czas oraz ma zawierać dodatkowe, komercyjne funkcjonalności. Zmienił się także sposób wprowadzania nowych zmian, od wersji 9tej, nowa wersja maszyny wirtualnej i języka Java ma być wydawana co pół roku, zaś co 3 lata ma być wydawana wersja LTS czyli Long Term Support, przeznaczona właśnie dla firm wymagających dłuższego utrzymania.

Na rynku dostępnych jest także sporo implementacji innych firm. IBM oraz fundacja Eclipse stoi za rozwojem maszyny wirtualnej IBM J9. Firma Azul System rozwija swoją otwarto źródłową wersję maszyny wirtualnej Zulu opartej o OpenJDK oraz komercyjną wersję Zing.

Jedną z nowości w świecie Java są prace nad nową wersją maszyny wirtualnej zwanej GraalVM. Celem projektu jest stworzenie jeszcze wydajniejszej wersji JVM wspierającej więcej języków programowania, jak JavaScript (także Node.js), C, C++, Rust, Ruby, R czy Python. GrallVM ma się stać także częścią baz danych MySQL oraz Oracle. W przeciwieństwie do innych maszyn wirtualnych, GraalVM jest napisany głównie w języku Java (97.3%).

Więcej innych implementacji wirtualnej maszyny możecie znaleźć na tej oraz tej stronie Wikipedii.

Każda licząca się maszyna wirtualna musi spełniać specyfikację oraz przejść Java Technology Compatibility Kit, TCK.

Wirtualna maszyna Java jest udostępniana w dwóch wersjach, Java Runtime Environment (JRE) zawierająca podstawową instalację maszyny wirtualnej wraz z dodatkowymi bibliotekami i komponentami, służącą przede wszystkim do uruchamiania programów oraz Java Development Kit (JDK) zawierająca wszystko co ma JRE plus dodatkowe narzędzia dla programistów. Poniżej diagram przedstawiający różnice między obydwiema wersjami dostępny na stronie Oracle.

Od kodu do programu, czyli proces kompilacji

Java jest językiem kompilowanym, to znaczy, że zanim uruchomimy nasz program, cały nasz kod będzie musiał zostać poddany procesowi kompilacji do postaci zrozumiałej dla komputera. W przypadku Javy, nasze programy będą uruchamiane przez maszynę wirtualną Java, więc narzędzie zwane kompilatorem będzie tłumaczyć nasz kod Java do postaci kodu maszynowego zrozumiałego dla JVM. Dlatego bez względu na to, jakiego języka programowania użyjemy, Java, Scala, Kotlin, Groovy, etc, nasz kod zawsze będzie tłumaczony do kodu maszyny wirtualnej, zwanego bytecode. Dopiero sama maszyna wirtualna tłumaczy ten kod dalej do postaci zrozumiałej przez system operacyjny naszego komputera.

Jako programiści będziemy pisać nasz kod Java w plikach .java, zaś kompilator będzie je tłumaczył na bytecode i umieszczał w plikach .class. W przypadku środowiska IntelliJ IDEA, pliki typu class znajdują się domyślnie w katalogu out. Po kliknięciu takiego pliku *.class w środowisku IntelliJ IDEA, możemy zobaczyć kod w języku Java. Dzieje się tak dzięki dekompilacji, czyli procesowi odwrotnemu do kompilacji, polegającemu właśnie na uzyskaniu kodu źródłowego z plików *.class. Oczywiście nie będzie to dokładnie nasz kod, tylko wygenerowany kod Java pasujący do zawartości pliku *.class.

Kompilator jest dla programistów bardzo przydatnym narzędziem. Już na etapie tłumaczenia naszego kodu na język maszyny wirtualnej jest w stanie wyłapać wszystkie błędy składni (dostajemy wtedy tak zwany błąd kompilacji) oraz ostrzega nas przed wieloma potencjalnymi błędami. Drugą zaletą języków kompilowanych jest możliwość “zrzucenia” części własnej pracy na kompilator, który może za nas wykonać część pracy, by skrócić nasz czas. Jednym z przykładów jest tutaj choćby słowo var, gdzie to kompilator domyśla się typu zmiennej.

Środowiska programistyczne proces kompilacji wykonują za nas. W praktyce, do budowania większych projektów używa się odpowiednich narzędzi jak Maven czy Gradle (wcześniej popularny był Ant), które także wykonują tą pracę za nas. Jednak nic nie stoi na przeszkodzie byśmy sami skompilowali nasz kod. Wraz z JDK dostajemy narzędzie javac, które jest właśnie kompilatorem języka Java. Co ciekawe, jest ono także stworzone w oparciu o język Java.

Załóżmy że mamy taką klasę Java:

package pl.kodolamacz.myclasses;

public class Person {

    public String forename;
    public String surname;
    public int age;

    public Person() {

    }

    public Person(String forename, String surname, int age) {
        this.forename = forename;
        this.surname = surname;
        this.age = age;
    }

    public void introduceYourself() {
        System.out.println("Nazywam się " + forename + " " + surname + ". Mam " + age + " lat.");
    }

    public int growOld(int age) {
        this.age += age;
        return this.age;
    }

}

Znajduje się ona w pliku Person.java. Żeby ją skompilować wystarczy w konsoli wpisać:

javac Person.java

Po wykonaniu powyższego polecenia, w tym samym katalogu powstanie plik Person.class. Zawartość nowo otrzymanego pliku nie jest zbyt czytelna dla człowieka, ale gdybyśmy chcieli zajrzeć do środka możemy użyć programu javap, który pozwala nam na rozłożenie pliku *.class na czynniki pierwsze (ang. disassemble). Domyślnie program javap wykonany bez żadnych parametrów pokazuje nam pakiet, pola public i protected oraz metody:

$ javap Person.class 
Compiled from "Person.java"
public class pl.kodolamacz.myclasses.Person {
  public java.lang.String forename;
  public java.lang.String surname;
  public int age;
  public pl.kodolamacz.myclasses.Person();
  public pl.kodolamacz.myclasses.Person(java.lang.String, java.lang.String, int);
  public void introduceYourself();
  public int growOld(int);
}

Jednak gdy dodamy flagę -c, wtedy program wyświetli nam instrukcje kodu maszynowego Java (bytecode) zgodnie ze specyfikacją języka:

$ javap -c Person.class 
Compiled from "Person.java"
public class pl.kodolamacz.myclasses.Person {
  public java.lang.String forename;

  public java.lang.String surname;

  public int age;

  public pl.kodolamacz.myclasses.Person();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public pl.kodolamacz.myclasses.Person(java.lang.String, java.lang.String, int);
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: aload_0
       5: aload_1
       6: putfield      #2                  // Field forename:Ljava/lang/String;
       9: aload_0
      10: aload_2
      11: putfield      #3                  // Field surname:Ljava/lang/String;
      14: aload_0
      15: iload_3
      16: putfield      #4                  // Field age:I
      19: return

  public void introduceYourself();
    Code:
       0: getstatic     #5                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: aload_0
       4: getfield      #2                  // Field forename:Ljava/lang/String;
       7: aload_0
       8: getfield      #3                  // Field surname:Ljava/lang/String;
      11: aload_0
      12: getfield      #4                  // Field age:I
      15: invokedynamic #6,  0              // InvokeDynamic #0:makeConcatWithConstants:(Ljava/lang/String;Ljava/lang/String;I)Ljava/lang/String;
      20: invokevirtual #7                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      23: return

  public int growOld(int);
    Code:
       0: aload_0
       1: dup
       2: getfield      #4                  // Field age:I
       5: iload_1
       6: iadd
       7: putfield      #4                  // Field age:I
      10: aload_0
      11: getfield      #4                  // Field age:I
      14: ireturn
}

Gotowy program

W przeciwieństwie do programów napisanych np. w języku C++, gotowe programy, czyli zbiór plików *.class, nie są umieszczane w pliku exe, lecz są pakowane do plików .jar. Plik jar to tak naprawdę plik typu zip, dlatego bez problemu możemy go otworzyć i zobaczyć co jest w środku oraz dzięki kompresji ma on mniejszy rozmiar. Oprócz plików *.class., we wnętrzu pliku jar mogą znajdować się dodatkowe pliki potrzebne do wykonania programu.

W środowisku IntelliJ IDEA, by zbudować plik jar ze swojego projektu, należy wejść do ustawień projektu (Plik -> Project Structure). W nowo otwartym oknie należy kliknąć zakładkę “Artifacts” z lewej strony, a następnie nacisnąć zielony przycisk “plus”. Z listy wybieramy opcję “JAR”, a następnie “From modules with dependencies”. W kolejnym okienku wskazujemy klasę z metodą main, którą chcemy uruchomić, naciskamy “OK” i zamykamy wszystkie okna ponownie naciskając “OK”. Gdy już mamy stworzony artefakt definiujący nasz plik jar, wystarczy go zbudować klikając “Build -> Build Artifacts”, a następnie wybierając nazwę naszego artefaktu i klikając znowu “Build”. Nasz plik pojawi się w katalogu “out/artifacts/**”.

Plik jar możemy uruchomić używając polecenia java:

java -jar my-jar.jar

Informacja o klasie, w której uruchamiana jest metoda main, znajduje się w pliku MANIFEST.MF:

Manifest-Version: 1.0
Main-Class: pl.kodolamacz.MyApplication

Jak to działa?

Jednak co się dzieje, gdy próbujemy uruchomić nasz plik jar? W pierwszej kolejności, uruchamiana jest maszyna wirtualna Java. Pierwszą rzeczą którą robi to załadowanie klas, czyli wczytanie plików .class znajdujących się w pliku jar. Odpowiada za to narzędzie zwane ClassLoader. Po wczytaniu następuje proces łączenia (Linking), który dzieli się na pięć etapów. Najpierw następuje weryfikacja (Verification) poprawności klas, potem faza przygotowania (Preparation) gdzie następuje stworzenie pól statycznych oraz ich inicjalizacja wartościami domyślnymi, a następnie etap rozwiązania (Resolution) zależności pomiędzy klasami, czyli upewnienia się, że wszystkie typy z których chcemy skorzystać są dostępne oraz czy mają oczekiwane pola i metody. To w ostatnim etapie możemy dostać takie błędy jak NoSuchFieldError, NoSuchMethodError, IllegalAccessError znane dobrze programistom Java. Gdy wszystko zostanie prawidłowo rozwiązane, następuje faza sprawdzenia dostępów do pól, metod i klas (Access Control), czyli uwzględnienie takich słów jak public, protected, private, a na koniec faza zastępowania nadpisanych metod (Overriding). Gdy już przeszliśmy przez proces łączenia (Linking), następuje faza inicjalizacji klas, po której są one już gotowe do użycia. Jeśli korzystamy z metod natywnych, np. napisanych w języku C++, są one ładowane po inicjalizacji klas. Teraz następuje wykonanie naszego programu. Gdy program zamyka się, wywoływana jest metoda System.exit(status), która znowu wywołuje Runtime.getRuntime().exit(status). Wtedy następuje zatrzymanie maszyny wirtualnej i zwolnienie wszystkich zasobów.

Proces ten w całości opisany jest w specyfikacji maszyny wirtualnej w rozdziale piątym.

Optymalizacja

W trakcie działania maszyny wirtualnej, nasz kod, dokładnie bytecode, jest tłumaczony na kod maszynowy i wykonywany. Na pierwszy rzut oka może się wydawać, że ten proces dodatkowego tłumaczenia jest zbyt dużym kosztem działania programu, przez co powstało wiele legend mówiących o tym, że Java czy ogólnie środowisko JVM jest wolne. Oczywiście nie jest to prawdą, bo maszyny wirtualne zawierają w sobie szereg optymalizacji stosowanych w trakcie wykonywania programu, przez co potrafią uruchamiać operacje prawie tak szybko jak natywny kod napisany w języku C/C++ czy nawet niekiedy szybciej. Dzieje się to dzięki dynamicznemu kompilatorowi JIT czyli Just-In-Time. Jego zadaniem jest właśnie tłumaczenie kodu maszyny wirtualnej (bytecode) do kodu maszynowego wykonywanego na danym urządzeniu. W swojej pracy uwzględnia on zarówno to jak program działa, jak i architekturę sprzętową na którym działa program. Dlatego potrafi on jednocześnie przyśpieszyć często używane fragmenty kodu (tak zwane gorące punkty) jak i zoptymalizować kod wynikowy z uwzględnieniem używanego typu procesora. To właśnie uwzględnianie danego sprzętu oraz to jak program pracuje może spowodawać, że stworzony przez JIT kod maszynowy może być tak wydajny. Oczywiście może się okazać, że próby optymalizacyjne zastosowane przez JIT nie przyniosły oczekiwanego skutku, lecz wręcz przeciwny, więc kompilator może się wycofać ze swoich zmian i inaczej skompilować kod wynikowy. Takie próby skutkują tym, że maszyna wirtualna, do osiagnięcia swojej pełnej wydajności, potrzebuje się “rozgrzać”. Dlatego największy zysk ze stosowania JIT uzyskamy dla programów działających przez dłuższy czas, stąd bardzo często Java jest stosowana w rozwiazaniach serwerowych.

Wyzwanie Java #3: Programowanie obiektowe

Sun, 29 Apr 2018 00:00:00 +0000

W dzisiejszym poście dotyczącym programowania w języku Java powiemy sobie o programowaniu obiektowym (ang. Object Oriented Programming, OOP). Wszystko co nas otacza, jest obiektem - przedmioty, zwierzęta, budynki, ludzie itd. itp. Żyjemy w świecie obiektów. Dlatego by łatwiej opisywać otaczający nas świat, podjęto próby przeniesienia go do języków programowania.

Jako pierwsi podjęli się tego zadania Ole-Johana Dahla i Kristena Nygaarda z Norweskiego ośrodka obliczeniowego w Oslo, którzy pracowali nad symulacjami zachowania się statków. Wprowadzili oni obiekty, klasy, dziedziczenie i wiele innych pojęć do języka Simula 67. Koncepcja OOP została następnie dopracowana w języku Smalltalk, który uważany jest za pierwszy w pełni obiektowy język programowania. Idea OOP zainspirowała duńskiego informatyka Bjarne Stroustrup’a do rozszerzenia języka C o paradygmat programowania obiektowego, dzięki czemu narodził się jeden z najpopularniejszych języków programowania jakim jest C++. Od tamtego momentu, czyli połowy lat 80tych, programowanie obiektowe stało się najpopularniejszym paradygmatem programowania. Innymi popularnymi paradygmatami jest programowanie strukturalne występujące w starszych językach programowania lub językach skryptowych oraz obecnie coraz popularniejsze programowanie funkcyjne, któremu poświęcimy oddzielne wyzwanie!

Z racji tego, że dobre zrozumienie idei programowania obiektowego jest niezmiernie ważne, by płynnie posługiwać się tym językiem programowania, prosimy Was o rzetelne i uważne przeczytanie poniższego artykułu.

Java i programowanie obiektowe

Java od początku istnienia jest językiem programowania, który jest językiem obiektowym. Koncepcja obiektów jest tutaj na tyle silna, że do tej pory, nie wiedząc jeszcze co to OOP, my także w swoich programach tworzyliśmy obiekty! Jedynym wyjątkiem jest optymalizacja użyta przez twórców języka, mianowicie typy proste, czyli poznane wcześniej typy jak int, long, double lub boolean. Twórcy zdecydowali się na wprowadzenie tego wyjątku, żeby zapewnić wysoką wydajność - zwłaszcza w początkach istnienia języka Java, gdy komputery były znacznie gorsze niż obecne. Jak się za chwilę dowiemy, te typy mają jednak swoich obiektowych braci.

Obiekty i klasy

Obiekt to jest jakiś byt, coś co istnieje w naszym programie. Oznacza to, że chcąc skorzystać z jakiegoś obiektu, musimy go najpierw stworzyć. Do tego celu nasz program musi mieć opis takiego obiektu, który nazywamy klasami. Gdyby chcieć przenieść to na świat codzienny, klasy są czymś w rodzaju projektu domu lub kodu DNA, zaś obiekt jest już zbudowanym budynkiem lub stworzeniem z danym kodem DNA. Do tworzenia klas w Javie używamy słówka class. Poniżej przykład takiej klasy:

package pl.kodolamacz;

public class MyFirstJavaApplication {

}

Powyższy kod jest nam bardzo dobrze znany, stworzyliśmy go w naszym pierwszym wyzwaniu! Widać w nim, że MyFirstJavaApplication jest właśnie klasą, czyli DNA naszego obiektu.

Pakiety

W pierwszej linii naszego powyższego kodu widzimy instrukcję package. Jest to tak zwany pakiet lub ścieżka pakietowa naszej klasy. Pakiety służą do logicznego podziału i segregacji naszego kodu oraz niwelują możliwość pojawienia się kolizji, gdy dwie osoby stworzą dwie klasy o takiej samej nazwie, pod warunkiem, że będą miały inne pakiety.

Zwyczajowo ścieżka pakietowa zaczyna się odwróconą domeną internetową naszej firmy, organizacji lub naszą własną, stąd kodolamacz.pl dał nam pl.kodolamacz, choć tak naprawdę możemy dowolnie kreować nazwy naszych pakietów, z wyjątkiem pakietów zaczynających się od słowa java, takich nie można tworzyć. Nazwy pakietów można w sobie dowolnie zagłębiać, dlatego zamiast pl.kodolamacz moglibyśmy śmiało skorzystać z ścieżki pl.kodolamacz.moj.super.pakiet. Fizycznie, pakiety są reprezentowane przez katalogi, dlatego jeśli odnajdziecie na swoim lokalnym dyski katalog z projektem i odnajdziecie tam katalog z źródłami waszego programu, czyli src (ang. source), to zobaczycie katalog pl a w nim podkatalog kodolamacz.

Klasy są zapisywane w plikach *.java. Jeden plik może zawierać tylko jedną klasę publiczną (słowo public przed class) oraz nazwa klasy i pliku musi być identyczna. (O innych typach klas powiemy sobie w kolejnym wyzwaniu)

Jeśli chcemy w naszym kodzie użyć innej klasy, z innego pakietu, musimy ją zaimportować do naszej klasy. Służy do tego słówko import. Jedynym wyjątkiem są klasy z pakietu java.lang, które są zawsze domyślnie importowane oraz klasy z tego samego pakietu co nasza klasa, ich także nie trzeba importować.

Poniżej przykład naszego programu z importem:

import java.util.Scanner;

Jeśli chcemy zaimportować kilka klas z jakiegoś pakietu, możemy użyć symbolu " * " w celu załadowania całego pakietu:

import java.util.*;

Pytanie, co jeśli chcemy użyć w naszym kodzie dwóch klas o takiej samej nazwie, ale w innym pakiecie? Na przykład klasa Date znajduje się zarówno w pakiecie java.util jak i java.sql (oczywiście są to dwie zupełnie inne klasy). Możemy wtedy pisząc nasz kod wskazać pełną nazwę klasy wraz z pakietami, jak w kodzie poniżej. Wtedy polecenie import nie będzie już nam potrzebne.

package pl.kodolamacz;

public class MyFirstJavaApplication {

    public static void main(String[] args) {
        java.util.Date date1 = new java.util.Date();
        java.sql.Date date2 = new java.sql.Date(System.currentTimeMillis());
    }

}

Od Java w wersji 5, można importować nie tylko klasy, ale także metody i pola statyczne. Korzystamy wtedy z polecenia import static. Poniżej przykład kodu Witaj Świecie z pierwszego wyzwania z użyciem importu statycznego, gdzie zaimportowaliśmy pole statyczne System.out, dzięki czemu nie musieliśmy pisać System.out.println(“Witaj świecie!”);

package pl.kodolamacz;

import static java.lang.System.out;

public class MyFirstJavaApplication {

    public static void main(String[] args) {
        out.println("Witaj świecie!");
    }

}

Metody i pola

Klasy składają się z metod (ang. methods) i pól (ang. fields). Pola klasy możemy rozumieć jako pewien zbiór cech, które możemy przypisać obiektowi, np. klasa człowiek może mieć pole wiek. Metody możemy traktować jako pewne akcje które możemy wykonać na obiekcie, jak np. zjedz czy pracuj. Poniżej przykład takiej klasy:

package pl.kodolamacz.myclasses;

public class Person {

    /**
     * Trzy pola naszej klasy
     */
    public String forename;
    public String surname;
    public int age;

    /**
     * Metoda przedstaw się wyświetlająca w konsoli napis
     */
    public void introduceYourself() {
        System.out.println("Nazywam się " + forename + " " + surname + ". Mam " + age + " lat.");
    }

}

Pola deklarujemy podobnie jak zmienne z poprzedniego wyzwania. Jedyna różnica jest taka, że mają zdefiniowany dostęp (słowo public), o którym powiemy więcej w dalszej części.

Metoda to jakiś kawałek kodu, który możemy wykonać na obiekcie. Metody mają zawsze dostęp do pól zadeklarowanych w tej samej klasie. Nasza metoda introduceYourself wyświetla nam informację o imieniu i nazwisku osoby. Metodę też możemy porównać do funkcji znanej z matematyki, np. y = ax + b. Taka funkcja y przyjmuje parametr x i korzystając z dwóch liczb a i b, które w naszym przypadku mogą być polami klasy, zwraca wynik tego działania. Tak samo metody w Javie mogą zwracać jakiś wynik oraz przyjmować parametry. Typ wyniku (np. int) podajemy przed nazwą metody, zaś przyjmowane parametry w nawiasach. Poniżej przykład metody przyjmującej parametr i zwracającej wynik, w tym przypadku zwiększającej i zwracającej ten wiek. Do zwrócenia wyniku używamy słowa kluczowego return. Jeśli metoda nie zwraca żadnej wartości, zamiast typu używamy słowa kluczowego void.

package pl.kodolamacz.myclasses;

public class Person {

    public String forename;
    public String surname;
    public int age;

    public void introduceYourself() {
        System.out.println("Nazywam się " + forename + " " + surname + ". Mam " + age + " lat.");
    }

    /**
     * Metoda dorośnij, zwiększająca wiek osoby o wskazaną ilość lat
     */
    public int growOld(int years) {
        age += years;
        return age;
    }

}

Gdy już mamy naszą klasę osoba, możemy stworzyć na jej podstawie obiekt, przypisać jego zmiennym wartości i wywołać jego metody. Do tworzenia klas służy słowo kluczowe new. Poniżej przykład wykonania wszystkich powyższych operacji:

package pl.kodolamacz;

import pl.kodolamacz.myclasses.Person;

public class MyThirdJavaApplication {

    public static void main(String[] args) {
        Person person1 = new Person(); // tworzymy obiekt
        person1.forename = "Jan"; // przypisujemy polu imię wartość
        person1.surname = "Kowalski";
        person1.age = 35;
        person1.introduceYourself(); // wywołujemy metodę
        person1.growOld(5); // metoda z parametrem
        person1.introduceYourself(); // jeszcze raz się przedstawiamy z innym wiekiem
    }

}

Proszę zauważyć, że klasa Person znajduje się w pakiecie pl.kodolamacz.myclasses, przez co musieliśmy użyć słowa kluczowego import by skorzystać z tej klasy w klasie MyThirdJavaApplication.

Dostęp do pól i metod obiektu odbywa się za pomocą znaku kropki podając najpierw nazwę obiektu, a następnie pole lub metodę z tego obiektu.

Nazwy klas i obiektów piszemy używając CamelCase, z tą różnicą, że w klasach pierwsza litera jest duża, zaś w nazwach zmiennych mała.

Konstruktor

Do stworzenia obiektu osoba z powyższego kodu użyliśmy słowa new. Podczas tej operacji wywoływany jest tak zwany konstruktor, czyli specjalna metoda, która tworzy nam nasz obiekt. Jeśli nie napiszemy sami konstruktora, klasa dostaje tak zwany konstruktor domyślny, który wygląda tak jak na poniższym przykładzie:

package pl.kodolamacz.myclasses;

public class Person {

    public String forename;
    public String surname;
    public int age;

    /**
     * Konstruktor domyślny
     */
    public Person() {

    }

    public void introduceYourself() {
        System.out.println("Nazywam się " + forename + " " + surname + ". Mam " + age + " lat.");
    }

    public int growOld(int years) {
        age += years;
        return age;
    }

}

Konstruktory nieco różnią się od zwykłych metod takich jak introduceYourself czy growOld. Ich nazwa musi być dokładnie taka sama jak nazwa klasy. Konstruktory także nie mają słowa void lub zwracanego typu.

Niestety, konstruktor domyślny nie pozwala nam przypisać wartości do tworzonych pól, dlatego zawsze możemy taki konstruktor zamienić na własny:

package pl.kodolamacz.myclasses;

public class Person {

    public String forename;
    public String surname;
    public int age;

    /**
     * Konstruktor domyślny
     */
    public Person() {

    }

    /**
     * Konstruktor z trzema parametrami
     */
    public Person(String initForename, String initSurname, int initAge) {
        forename = initForename;
        surname = initSurname;
        age = initAge;
    }

    public void introduceYourself() {
        System.out.println("Nazywam się " + forename + " " + surname);
    }

    public int growOld(int years) {
        age += years;
        return age;
    }

}

Mając nasz konstruktor możemy już w zupełnie inny sposób napisać nasz program:

package pl.kodolamacz;

import pl.kodolamacz.myclasses.Person;

public class MyThirdJavaApplication {

    public static void main(String[] args) {
        Person person1 = new Person(); // tworzymy obiekt
        person1.forename = "Jan"; // przypisujemy polu imię wartość
        person1.surname = "Kowalski";
        person1.age = 35;
        person1.introduceYourself(); // wywołujemy metodę
        person1.growOld(5); // metoda z parametrem
        person1.introduceYourself(); // poprzednia metoda po zmianie parametrów

        Person person2 = new Person("Tomasz", "Nowak", 56); // konstruktor z parametrami
        person2.introduceYourself();
    }

}

W powyższym kodzie stworzyliśmy już dwa obiekty klasy Person. W tym przypadku nie musimy ustawiać parametrów przez odwołanie się do obiektu, wystarczy przekazać je do konstruktora.

Gdybyśmy chcieli użyć parametru metody lub konstruktora o takiej samej nazwie jak jedno z pól, możemy nadal odwołać się do pola, poprzez użycie słowa this. Poniżej przykład konstruktora oraz metody z kolizją nazw parametrów i pól:

package pl.kodolamacz.myclasses;

public class Person {

    public String forename;
    public String surname;
    public int age;

    /**
     * Konstruktor domyślny
     */
    public Person() {

    }

    /**
     * Konstruktor z trzema parametrami
     */
    public Person(String forename, String surname, int age) {
        this.forename = forename;
        this.surname = surname;
        this.age = age;
    }

    public void introduceYourself() {
        System.out.println("Nazywam się " + forename + " " + surname + ". Mam " + age + " lat.");
    }

    public int growOld(int age) {
        this.age += age;
        return this.age;
    }

}

Kontrola dostępu do klas

Klasy mają swój zasięg. Dzielimy je na klasy publiczne public class oraz na pakietowe (package-private), kiedy to mamy tylko słówko class bez public. Klasy publiczne można importować w dowolnej innej klasie, zaś klas pakietowych możemy używać tylko w klasach w tym samym pakiecie!

Dodatkowo wyróżniamy 4 modyfikatory dostępu do pól i metod klasy:

public - wszyscy mają dostęp
protected - widzą wszyscy w tym pakiecie i Ci co rozszerzają tą klasę
default - widać tylko w tym pakiecie
private - tylko ta klasa widzi swoje pola

Powyższą zasadę można przedstawić za pomocą tabeli:

	Klasa	Pakiet	Podklasa	Wszyscy
public	+	+	+	+
protected	+	+	+
default	+	+
private	+

Należy zauważyć, że widoczność default uzyskujemy nie wpisując żadnego słowa przy polu, metodzie lub klasie! W Javie mamy słowo kluczowe default, ale służy do zupełnie czegoś innego, o czym przekonamy się w kolejnym wyzwaniu.

Metody i pola statyczne

We wcześniejszych przykładach tworzyliśmy pola i metody które należały do obiektu, to znaczy, by się do nich odwołać (pola) lub je wykonać metody musieliśmy najpierw stworzyć obiekt z naszej klasy. Są jednak sytuacje, gdzie dla skorzystania z jakichś pól lub metod, nie chcemy tworzyć nowych obiektów. Dobrym przykładem tutaj mogą być jakieś stałe wartości jak liczba PI lub funkcje matematyczne. Poniżej klasa Circle reprezentująca koło/okrąg wraz z promieniem (radius) oraz metodami zwracającymi pole powierzchni koła oraz obwód okręgu.

package pl.kodolamacz;

public class Circle {

    private int radius;

    public Circle(int radius) {
        this.radius = radius;
    }

    public double area() {
        return Math.PI * Math.pow(radius, 2);
    }

    public double circumference() {
        return 2 * Math.PI * radius;
    }

}

W powyższym kodzie użyta została stała Math.PI oraz metoda Math.pow() klasy Math z pakietu java.lang (niepotrzebny import!). By z nich skorzystać nie tworzyliśmy obiektu klasy Math (nie jest to nawet możliwe gdyż konstruktor ma dostęp oznaczony jako private), a jedynie skorzystaliśmy bezpośrednio z samej metody i pola klasy. Takie pola i metody z których możemy skorzystać bez obiektu nazywamy statycznymi. Tworzymy je za pomocą słowa static. Poniżej interesująca nas metoda i stała klasy java.lang.Math:

package java.lang;

public final class Math {

    /**
     * Don't let anyone instantiate this class.
     */
    private Math() {}
    
    public static final double PI = 3.14159265358979323846;

    public static double pow(double a, double b) {
        return StrictMath.pow(a, b);
    }

}

W powyższym przykładzie skorzystaliśmy z klasy wbudowanej w język Java. Dodatkowo sami także możemy tworzyć oraz wykorzystywać pola i metody statyczne. Także metoda main, której używaliśmy w tym i poprzednich wyzwaniach, jest właśnie metodą statyczną!

Zarówno pole Math.PI oraz metodę Math.pow() możemy zaimportować statycznie. Nasz kod będzie wtedy wyglądać tak:

package pl.kodolamacz;

import static java.lang.Math.PI;
import static java.lang.Math.pow;

public class Circle {

    private int radius;

    public Circle(int radius) {
        this.radius = radius;
    }

    public double area() {
        return PI * pow(radius, 2);
    }

    public double circumference() {
        return 2 * PI * radius;
    }

}

W niektórych językach programowania wprowadza się oddzielnie pojęcie metody i funkcji. Metody są związane z jakimś obiektem, zaś funkcje są samoistnymi bytami. W języku Java nie ma możliwości stworzenia funkcji, czyli metody poza klasą, dlatego nawet metody statyczne z których możemy korzystać bezpośrednio wskazując klasę, a nie obiekt, są tak naprawdę metodami, a nie funkcjami.

Typy proste a obiekty

Jak dowiedzieliśmy się wcześniej, typy proste takie jak int, long, double czy boolean nie są obiektami. Zdecydowali to twórcy języka w celu osiągnięcia większej wydajności. Mimo to, każdy z typów prostych ma swój “obiektowy” odpowiednik. Dodatkowo w javie mamy mechanizm zwany Autoboxing oraz Unboxing automatycznie konwertujący typy proste w obiekty i odwrotnie. Poniżej przykłady konwersji typów prostych na i z obiektów:

package pl.kodolamacz;

public class AutoboxingAndUnboxing {

    public static void main(String[] args) {
        int a1 = 5;
        int a2 = new Integer(7); // konstruktor jest deprecated
        Integer a3 = new Integer(-8);
        Integer a4 = -19;
        Integer a5 = Integer.valueOf(34);

        String s1 = "Text 1";
        String s2 = new String("Text 1");

        Character ch1 = 'a';
        char ch2 = 'a';
    }

}

Poniżej tabela pokazująca mapowanie typów prostych na ich wersje obiektowe lub inaczej opakowujące (ang. wrapper):

Typ prosty	Wrapper
boolean	Boolean
byte	Byte
char	Character
float	Float
int	Integer
long	Long
short	Short
double	Double

Wyzwanie

A teraz nasze wyzwanie. Nasz kalkulator, który stworzyliśmy w poprzednim wyzwaniu, miał jeden mały problem - operacje zmiennoprzecinkowe, czyli takie które przyjmowały lub tylko zwracały liczby niecałkowite (np. 10 podzielić na 3) zaokrąglały wynik. Niestety jest to problem, gdy zależy nam na bardzo dużej dokładności i nie możemy pozwolić sobie na zaokrąglenia (np. operacje finansowe). Dlatego w tym wyzwaniu chcielibyśmy, byście stworzyli ulepszoną wersję kalkulatora, która nie pracuje na liczbach typu double, a na waszej klasie Fraction (ułamek). Klasa ta powinna posiadać pole licznika, mianownika i części całkowitej oraz metody pozwalające na dodawanie, odejmowanie, mnożenie, dzielenie i skracanie ułamków, czyli wszystkie najważniejsze operacje jakich mogliśmy się nauczyć w szkole. Program powinien wszystkie wczytywane liczby w kalkulatorze od razu zamieniać na ułamki i na nich dokonywać wszystkich działań. Należy pamiętać o sprowadzaniu ułamków do wspólnego mianownika. Oczywiście chcemy stworzyć klasę Fraction samodzielnie, bez posiłkowania się klasami z pakietu java.math.

Rozwiązanie wyzwania #3 opublikujemy w piątek na stronie naszego wydarzenia na Facebooku. W międzyczasie będziemy tam też zamieszczać materiały dodatkowe, które uzupełnią Waszą wiedzę na temat Javy i pracy programisty.

Jak uda się Wam poprawnie wykonać zadanie - pochwalcie się tym koniecznie w przeznaczonym do tego poście na FB!

Kolejna część wyzwania za tydzień, 7 maja o godz. 10:00.

Powodzenia!

Czego się uczyć by zostać programistą?

Fri, 27 Apr 2018 00:00:00 +0000

Coraz więcej osób widzi swoją przyszłość w zawodzie programisty. Rewolucja informatyczna która dzieje się na naszych oczach spowodowała, że zawód “informatyka” stał się coraz bardziej rozpoznawalny i doceniany. Mimo, że nasze najmłodsze pociechy pytane o zawód nadal wybierają strażaka, policjanta, nauczyciela czy sportowca, to ich starsi koledzy zaczynają traktować zawód programisty na równi z lekarzem, prawnikiem czy ekonomistą. Widać to choćby coraz mocniej na w rankingach najpopularniejszych kierunków studiów. Pomimo różnych stereotypów powielanych latami, programowanie wydaje się stawać społecznie coraz ciekawszym zajęciem na przyszłość. Przyczyniają się do tego oczywiście życiorysy znanych osób takich jak Bill Gates, założyciel firmy Microsoft i jeden z najbogatszych ludzi świata; Steve Jobs i Steve Wozniak, założyciele firmy Apple; Larry Page i Sergey Brin, założyciele firmy Google; Elon Musk, założyciel firm takich jak PayPal, SpaceX oraz Tesla; Mark Zuckerberg, założyciel portalu Facebook czy Kevin Mitnick, jeden z najbardziej znanych włamywaczy komputerowych. Są to ludzie którzy odnieśli niebywały sukces i ich nazwiska są rozpoznawalne na całym świecie, nawet przez osoby nie związane w żaden sposób z informatyką. Programiści oraz ludzie z wykształceniem technicznym coraz częściej stają się także bohaterami filmów i seriali, jak choćby znane Dolina Krzemowa, Technicy magicy czy Teoria wielkiego podrywu.

Historia

Za pierwszego programistę (a właściwie programistkę) w historii uważa się Adę Lovelace, która w październiku 1842 roku opublikowała algorytm przeznaczony do wykonania na maszynie Charlesa Babbage. Niektórzy jednak za pierwszego programistę uważają znacznie starszego Joseph’a Marie Jacquard’a, który stworzył maszynę Jacquarda, którą można było sterować za pomocą kart perforowanych. Początkowo przez dłuższy czas, właśnie na podobnych kartach programowało się komputery. Osobą, która jako pierwsza uruchomiła program na komputerze w 1941 roku był Konrad Zuse.

Za pierwszy wysokopoziomowy język programowania uważany jest język Fortran stworzony w roku 1954. Pięć lat później narodził się język COBOL który powstał dla systemów bankowych. W dwudziestym wieku praktycznie każda transakcja bankowa była przetwarzana przez systemy napisane w tym właśnie języku i jest on używany do dzisiaj. W 1964 roku powstał kolejny znany język programowania zwany BASIC. W 1969 roku narodził się jeden z najpopularniejszych języków programowania, czyli język C, który stopniowo ewaluował w język C++ (1983 rok). W 1994 roku w Holandii wydano pierwszą wersję języka Python który zyskał nazwę od Latającego Cyrku Monty Pythona. W 1993 roku, w Japonii, narodził się język Ruby, który miał czerpać to co najlepsze z języków takich jak Python, Perl i Smalltalk. W 1995 roku narodził się język PHP (Personal Home Page) oraz język Java. Rok później została wydana pierwsza wersja języka JavaScript, będącego najpopularniejszym językiem programowania używanym przy tworzeniu stron internetowych. Ostatni z najpopularniejszych języków programowania narodził się w 2000 roku, kiedy to firma Microsoft opracowała język C#. Oczywiście języków programowania jest znacznie więcej, tutaj tylko historia kilku najpopularniejszych. Jak widać, Java jest jednym z młodszych z obecnie używanych języków programowania.

Kim są programiści?

Informatyka to dyscyplina naukowa wchodząca zarówno w skład obszaru nauk ścisłych w dziedzinie nauk matematycznych, jak i w obszar nauk technicznych w dziedzinę nauk technicznych. Więcej o obszarach, dziedzinach i dyscyplinach naukowych można przeczytać w rozporządzeniu Ministra Nauki i Szkolnictwa Wyższego. Pomijając klasyfikację, informatyka to bardzo szeroka gałąź nauki, mająca swoje podłoże zarówno w matematyce jak i technice. Dlatego pojęcie “informatyk” bywa bardzo mylące i nie wiele mówiące o zawodzie danej osoby. Dlatego programista, czyli osoba tworząca oprogramowanie, zajmuje się informatyką, jednak jest to dużo szersze pojęcie i nie zawsze związane z programowaniem.

O programistach mówi się żartobliwie jako o osobach “przetwarzających filiżanki kawy na kod”. W przypadku języka Java, którego nazwa pochodzi od ziaren kawy z wyspy Java, nabiera to jeszcze większego sensu.

Tak naprawdę programowanie zawodowo odbiega od tego jak możemy sobie ten zawód wyobrażać na początku naszej przygody z programowaniem. Nie zamierzam tutaj w żadnym wypadku nikogo straszyć, a jedynie pokazać pracę programisty z dużo szerszej perspektywy, bowiem okazuje się, że sama umiejętność programowania w wybranym języku, to zaledwie kropla w morzu potrzeb, niczym kropla w filiżance kawy.

Czego się uczyć by zostać zawodowym programistą?

Rzeczą oczywistą jest, że programista powinien znać przynajmniej jeden język programowania. Przynajmniej, bo dzisiaj coraz więcej mówi się o podejściu zwanym Polyglot Programming. Uczenie się wielu języków programowania ma wiele zalet. Możemy zawsze wybierać najwłaściwszy język do konkretnego zastosowania, zwiększając zarazem swoje kompetencje i możliwości. Takie podejście do programowania rozwija nas, bo możemy patrzeć na języki programowania z perspektywy wielu różnych pomysłów i rozwiązań zastosowanych przez ich twórców. Tak naprawdę bardzo często zdarza się, że twórcy jednego języka inspirują się w nowych wersjach pomysłami z innych języków programowania.

Skoro informatyka, a tym samym programowanie, bazuje na matematyce i innych naukach technicznych, okazuje się, że często bywa przydatne posiadanie gruntownej wiedzy teoretycznej. O ile przy tworzeniu prostych aplikacji ta wiedza nie jest nam aż tak potrzebna, to coraz więcej programistów pracuje w projektach związanych z zaawansowanym przetwarzaniem danych, uczeniem maszynowym, sztuczną inteligencją czy obliczeniami rozproszonymi, gdzie taka wiedza jest wręcz niezbędna. Nietrudno znaleźć w internecie oferty pracy firmy Google gdzie oprócz znajomości języka Java, wymagane jest posiadanie stopnia doktora informatyki. Nie każdy oczywiście, chce poświęcić kilka lat by napisać doktorat, nie każdy też będzie pracować przy analizowaniu danych, jednak wiedza na temat tak zwanych algorytmów i struktur danych to minimum, które każdy programista powinien znać i często możemy spotkać się z pytaniami z tego zakresu na rozmowach kwalifikacyjnych.

Programując będziemy musieli poznać także teoretyczne podstawy stojące za ideą programowania obiektowego i funkcyjnego, poznać czym to jest i jak prawidłowo tego używać.

Znajomość jednego czy nawet wielu języków programowania na poziomie wręcz mistrzowskim, wcale nie gwarantuje, że będziemy potrafili pisać dobre programy. Dlatego niezbędna staje się wiedza także z takich tematów jak wzorce projektowe, dobre praktyki programowania czy czystość kodu. W swojej pracy będziemy także mogli spotkać się z takimi terminami jak Domain Driven Design lub Behaviour-Driven Development. Nie raz też usłyszymy o dobrej architekturze naszych aplikacji. Jest to wiedza, której przyswojenie zajmuje sporo czasu i wymaga doświadczenia, ale zwraca się z nawiązką czyniąc z nas dużo lepszych specjalistów.

Kolejnym niezwykle ważnym zagadnieniem podczas programowania jest umiejętność testowania naszego kodu. Musimy tutaj poznać wiele różnych narzędzi i bibliotek jak choćby JUnit, Mockito, AssertJ oraz czym są testy jednostkowe, jak pisać dobre testy jednostkowe, czym jest Test Driven Development oraz przyswoić inne pojęcia z tego zakresu.

Nie da się programować bez poznania odpowiednich narzędzi, począwszy od IDE (Zintegrowane środowisko programistyczne) przechodząc przez bazy danych, narzędzia do budowania jak np. Maven, środowiska Continuous Integration i Continuous Delivery.

Programując nigdy nie piszemy wszystkiego sami, bardzo często korzystamy z kodu napisanego przez innych programistów, dlatego w naszej pracy będziemy używać wielu bibliotek i frameworków do tego służących. Do najpopularniejszych bibliotek i frameworków stosowanych przez programistów Java należą np. Spring i Hibernate.

Jeśli chcemy programować aplikacje internetowe, będziemy także musieli poznać narzędzia takie jak serwery aplikacyjne (np. Tomcat, JBoss), biblioteki JavaScript do tworzenia stron internetowych jak Angular, React czy Vue.jd, język HTML oraz CSS. Jeśli znowu chcemy tworzyć aplikacje mobilne musimy poznać np. środowisko Androida, zaś do pisania aplikacji okienkowych biblioteki takie jak Swing, SWT lub JavaFX.

Współpracując z innymi programistami nad wspólnym projektem, nie sposób obejść się bez narzędzia, które pozwoli nam wymieniać się kodem oraz przechowywać jego historię zmian. Takie narzędzie nazywamy systemami kontroli wersji. Najpopularniejszym systemem kontroli wersji jest Git, z którego możemy bezpłatnie skorzystać na popularnym portalu GitHub.

Pracując w zespole, będziemy też musieli poznać różne techniki prowadzenia projektów pozwalające nam organizować naszę pracę, dlatego nie obce powinny być nam takie zwroty jak Agile, Scrum, Kanban i inne.

Podsumowanie

Jak widać, zostanie programistą wymaga naprawdę sporo pracy. Jeśli marzy się Wam kariera w świecie IT potraktujcie powyższy spis jako listę rzeczy których musicie się nauczyć by osiągnąć sukces. Jednak nie martwcie się, nie jest to wszystko takie trudne jak może na początku się wydawać! Nie wszystko też musicie od razu umieć by dostać swoją pierwszą pracę jako tak zwany młodszy programista lub junior developer, pewne rzeczy będziecie poznawać stopniowo pracując z bardziej doświadczonymi programistami.

Wyzwanie Java #2: Podstawowe instrukcje - rozwiązanie

Fri, 27 Apr 2018 00:00:00 +0000

Drugie nasze wyzwanie było już znacznie trudniejsze od poprzedniego, wymagało większego wysiłku, zabawy z kodem czy nawet w niektórych przypadkach doczytania czegoś dodatkowo by zrealizować wasze pomysły. Mimo to poszło Wam świetnie, nadesłaliści wiele różnych, prawidłowych i bardzo ciekawych rozwiązań.

Zadanie polegało na stworzeniu uproszczonej wersji kalkulatora. Nasz program miał działać w sposób podobny do poniższego, czyli pobierać od użytkownika dwie liczby, operację matematyczną oraz.

Proszę podaj w oddzielnych linijkach jakąś liczbę, operację matematyczną +,-,*,/,%, a następnie kolejną liczbę:
12
+
3
Twój wynik to: 15
Chcesz wykonać kolejne działanie? Wpisz literę t lub n.

W najprostszej postaci nasz program mógłby wyglądać na przykład tak:

package pl.kodolamacz;

import java.util.Scanner;

public class SimpleCalculator {

    public static void main(String[] args) {

        var scanner = new Scanner(System.in);

        System.out.println("Proszę podaj w oddzielnych linijkach jakąś liczbę, operację matematyczną +,-,*,/,%, a następnie kolejną liczbę:");

        String runAgain;
        do {

            var x = scanner.nextDouble();
            scanner.nextLine();

            var operation = scanner.nextLine();

            var y = scanner.nextDouble();
            scanner.nextLine();

            double result;
            if (operation.equals("+")) {
                result = x + y;
            } else if (operation.equals("-")) {
                result = x - y;
            } else if (operation.equals("*")) {
                result = x * y;
            } else if (operation.equals("/")) {
                result = x / y;
            } else if (operation.equals("%")) {
                result = x % y;
            } else {
                System.out.println("Nieznana operacja!");
                result = 0;
            }
            System.out.println("Twój wynik to: " + result);

            System.out.println("Chcesz wykonać kolejne działanie? Wpisz literę t lub n.");
            runAgain = scanner.nextLine();

        } while (runAgain.equals("t"));

        scanner.close();
    }

}

Powyższy program robi to co powinien. Mimo to wiele osób zauważyła szereg możliwości ulepszenia swoich programów! Pierwszą rzeczą na którą powinniśmy zwrócić uwagę to obsługa sytuacji wyjątkowych takich jak podanie napisu zamiast liczby i odwrotnie, podanie złego znaku operacji, czy nawet dzielenie przez zero. W kolejnych wyzwaniach powiemy sobie więcej o błędach i wyjątkach w Javie, ale już tutaj warto w jakimś zakresie je obsłużyć.

Pamiętajcie także, że w Javie liczby niecałkowite zapisujemy jako double a nie int, czyli korzystając z tego drugiego typu danych (lub innego całkowitego), utracimy informację o części ułamkowej wyniku, stąd w powyższym przykładzie pracujemy na double. Jeśli korzystaliście z int sprawdźcie wynik dzielenia z resztą w waszym kalkulatorze :)

Wiele też osób w swoim zakresie zauważyła, że ciąg warunków if-els, można zmienić na instrukcję switch. Tą instrukcję wprowadzimy oficjalnie w jednym z kolejnych wyzwań, ale jak najbardziej także tutaj można jej użyć.

Innym problemem który także spotykaliście, to funkcja nextDouble lub podobna w klasie Scanner która czyta samą liczbę a nie całą linijkę, dlatego trzeba było albo konwertować linię samodzielnie do liczby albo po wczytaniu liczby dodatkowo wczytać linię do końca.

Pamiętajcie też, że zmienne muszą być zawsze zadeklarowane przed użyciem a także kompilator nie pozwoli nam napisać kodu gdzie świadomie nic nie przypisujemy do zmiennej a potem chcemy jej użyć, stąd w powyższym przykładzie przypisanie zera gdy użytkownik podał błędną operację matematyczną.

Ostatnią radą dla Was jest różnica między Stringiem czyli ciągiem znaków a pojedynczym znakiem czyli typem char. Obsłudze napisów poświęcimy oddzielne wyzwanie, ale już tutaj trzeba pamiętać, że napis, czyli String to zestaw znaków, więc “a” nie jest równoważne z ‘a’, bo jedno to napis (String) a drugie jeden konkretny znak! Pamiętajcie też, że łańcuchy znaków zawsze porównujemy dla bezpieczeństwa metodą equals a nie ==, pomimo, że w niektórych przypadkach może to zadziałać, o czym także powiemy sobie w wyzwaniu dotyczącym napisów.

Jeśli macie więcej pytań lub problemów, piszcie do nas śmiało, chętnie pomożemy :) Do zobaczenia w poniedziałek na kolejnym wyzwaniu!

Wyzwanie Java #2: Podstawowe instrukcje

Mon, 23 Apr 2018 00:00:00 +0000

W poprzednim wyzwaniu przygotowaliśmy sobie środowisko do pracy i stworzyliśmy swój pierwszy program. Dzisiaj chcemy podnieść poprzeczkę i poznać podstawowe instrukcje wykorzystywane w języku Java!

Przed nami takie rzeczy jak:

Komentarze
Zmienne i stałe
Typy danych
Operatory
Instrukcje sterujące
Pętle

Zaczynamy!

Komentarze

Zaczniemy od zagadnienia dość prostego, ale przydatnego na kolejnych etapach nauki, mianowicie komentarzy. Komentarz to tak naprawdę dowolny kawałek naszego kodu, który nie zostanie uwzględniony w programie. Komentarze mogą służyć do zostawienia krótkiej informacji dla innych programistów lub czasami “wyłączenia” kawałka kodu, w trakcie pisania i testowania naszego programu.

Wyróżniamy trzy rodzaje komentarzy:

liniowe - od znaków // do końca linii
blokowe - wszystko pomiędzy znakami /* i */
Javadoc - służy do tworzenia dokumentacji

Poniżej przykład użycia w kodzie takich komentarzy:

package pl.kodolamacz;

/**
 * To jest Javadoc 
 * dla klasy
 */
public class MyFirstJavaApplication {

    /**
     * Tutaj Javadoc 
     * dla funkcji
     */
    public static void main(String[] args) {

        // Tutaj jest komentarz liniowy

        /*
        To jest komentarz blokowy
        Może on mieć wiele linii
         */
    }

}

Komentarzy będziemy używać w przykładach kodu w celu wyjaśnienia niektórych instrukcji. Więcej o komentarzach możemy poczytać tutaj: http://www.oracle.com/technetwork/articles/java/index-137868.html

Zmienne

W poprzednim programie wczytywaliśmy od użytkownika jego imię i nazwisko, a następnie wyświetlaliśmy te informacje. Nasz program wyglądał mniej więcej tak:

package pl.kodolamacz;

import java.util.Scanner;

public class MyFirstJavaApplication {

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);

        System.out.println("Proszę podaj swoje imię:");
        String forename = scanner.nextLine();

        System.out.println("Proszę podaj swoje nazwisko:");
        String surname = scanner.nextLine();

        scanner.close();

        System.out.println("Witaj " + forename + " " + surname);
    }

}

Aby taki program mógł zadziałać, musieliśmy w jakiś sposób zapamiętać sobie naszą wartość, czyli imię i nazwisko użytkownika. Potrzebujemy do tego czegoś w rodzaju “pudełka” na dane, gdzie będziemy mogli w każdej chwili coś włożyć, a potem pobrać i w razie potrzeby włożyć coś innego. Takie “pudełka” na dane w językach programowania nazywamy zmiennymi (ang. variable).

W naszym kodzie z wyzwania stworzyliśmy dwie zmienne, forename i surname:

String forename = scanner.nextLine();
String surname = scanner.nextLine();

Nazwa zmiennej musi się zaczynać literą oraz może składać się z liter i cyfr. Za “literę” w Javie traktujemy dowolny znak Unicode (https://pl.wikipedia.org/wiki/Unikod), w tym także polskie znaki potocznie nazywane literami z ogonkami jak np. “ą”. Przyjęto jednak zwyczajowo, że nasze programy piszemy w języku angielskim, ułatwia to współpracę z programistami z całego świata oraz unikamy problemów z kodowaniem.

W nazwach zmiennych możemy używać zarówno dużych i małych liter, trzeba jednak pamiętać, że wielkość liter ma znaczenie i zmienna forename, Forename czy foreName to zupełnie inne zmienne. Przyjęto, że w Javie stosujemy notację camelCase (https://pl.wikipedia.org/wiki/CamelCase), czyli nazwy zmiennych zaczynamy zawsze małą literą, zaś w przypadku nazw będących złożeniem kilku słów, każde kolejne słowo zaczyna się dużą literą, np. myDogName.

Dodatkowo nie można stosować w nazwach symboli taki jak “+”, spacji oraz słów zarezerwowanych (https://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html).

Więcej o “zwyczajach” stosowanych w języku Java, czyli tak zwanych konwencjach, możemy przeczytać tutaj: http://www.oracle.com/technetwork/java/codeconventions-150003.pdf. Oczywiście nie ma obowiązku ich przestrzegania, jest to jednak mocno zalecane i ułatwia współpracę z innymi programistami. Zdarza się także, że różne firmy tworzą własne reguły pisania kodu, gdybyśmy chcieli zobaczyć jak robi to firma Google wystarczy zajrzeć na stronę: https://google.github.io/styleguide/javaguide.html.

Typy danych

Java jest językiem o ścisłej kontroli typów (https://pl.wikipedia.org/wiki/Typowanie_statyczne). Oznacza to, że każda zmienna ma z góry określony typ, czyli informację o tym co można do takiej zmiennej zapisać. Typy dzielimy na proste (ang. primitive) oraz złożone, czyli obiekty o których powiemy sobie więcej w kolejnych wyzwaniach.

Do typów prostych zaliczamy:

byte - przechowuje liczby całkowite z zakresu od -128 do 127
short - przechowuje liczby całkowite z zakresu od -32 768 do 32 767
int - przechowuje liczby całkowite z zakresu -231 do 231-1
long - przechowuje liczby całkowite z zakresu -263 do 263-1
float - przechowuje liczby zmiennoprzecinkowe 32 bitowe zgodne ze standardem IEEE 754
double - przechowuje liczby zmiennoprzecinkowe 64 bitowe zgodne ze standardem IEEE 754
boolean - przechowuje wartość logiczną (prawda lub fałsz, ang. true or false)
char - przechowuje znaki (dokładnie znaki Unicode, 16-bit, 0-65,535)

Brzmi to dość skomplikowanie, ale wcale tak nie jest. Pierwsze cztery typy przechowują liczby - im większa liczba, tym “bardziej pojemny” typ musimy użyć, co oczywiście skutkuje zużyciem większego miejsca w pamięci komputera. Kolejne dwa typy, czyli float i double przechowują liczby niecałkowite, które nazywamy w informatyce zmiennoprzecinkowymi - im “więcej miejsc po przecinku”, tym typu o większej precyzji musimy użyć, czyli double zamiast float. Typ boolean przechowuje dwa rodzaje wartości, true lub false i zostanie pokazany w rozdziale z warunkami. Ostatni typ służy do przechowywania pojedynczych znaków, czyli np. liter lub cyfr.

Więcej informacji o typach możemy znaleźć pod adresem: https://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html

Łańcuchy znaków

W Javie nie ma wbudowanego typu prostego dla łańcucha znaków, czyli jakiegoś napisu. W zamian mamy klasę String pozwalającą nam na przypisanie napisów. O łańcuchach powiemy sobie więcej w innym wyzwaniu, gdzie skupimy się na obsłudze dat i napisów w Javie.

Poniżej przykład stworzenia dowolnego łańcucha:

String text = "To jest dowolny tekst";

Deklaracja

Zmienne w języku Java trzeba deklarować, czyli podać typ oraz nazwę zmiennej, np:

int days;
long miliseconds;
float avg;
double money;
boolean success;
char character;

Możemy też zadeklarować kilka zmiennych razem, gdy są tego samego typu:

int days, months;

ale nie jest to zalecane, gdyż utrudnia czytanie programów.

Inicjalizacja

Zmiennych które są tylko zadeklarowane nie możemy użyć, dlatego trzeba najpierw je zainicjalizować, czyli przypisać im jakąś wartość początkową:

days = 5;
miliseconds = 1212312807128L;
avg = 4.5f;
money = 50.6;
success = true;
character = 'a';

Najlepiej jest jednak deklarować zmienne i je inicjalizować w tej samej linijce jak poniżej:

int days = 5;
long miliseconds = 1212312807128L;
float avg = 4.5f;
double money = 50.6;
boolean success = true;
char character = 'a';

Jeśli nie jest to możliwe, należy deklarację napisać jak najbliżej w kodzie miejsca inicjalizacji, kod będzie łatwiejszy do analizowania.

W powyższym przykładzie powiedzieliśmy kompilatorowi, że nasza zmienna days ma mieć na początku wartość równą 5, zaś money wartość równą 50.6. Liczbę 5 oraz 50.6 w tym przypadku nazywamy literałem (ang. literal), czyli konkretną wartością zapisaną w naszym kodzie. Należy zauważyć, że literały w Javie domyślnie są typu int oraz double dlatego w przypadku literałów typu long i float pojawiły się odpowiednio litery L oraz f. Więcej przykładów takich literałów możemy znaleźć w dokumentacji na stronie: https://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html

Słowo var

W starszych wersjach języka Java zawsze musieliśmy podawać typ zmiennej. Od wersji 10 języka nie musimy tego robić, możemy pozwolić by kompilator domyślił się tego za nas. Korzystamy wtedy ze słówka var będącego skrótem słowa variable czyli zmienna. Powyższy fragment kodu możemy w takim razie zapisać jako:

var days = 5;
var money = 50.6;

W kolejnych przykładach kodu, będziemy na przemian korzystać ze słówka var lub deklaracji typu zmiennej, by przyzwyczaić się do obydwu możliwości.

Stałe

Wartość przechowywaną w zmiennej w każdej chwili możemy zmienić na inną (stąd też nazwa zmienna). Jednak czasami potrzebujemy powiedzieć kompilatorowi oraz innym programistom, że coś ma być “stałe”. Wtedy warto skorzystać ze słówka final.

Poniższy kod jest prawidłowy:

int days = 5;
days = 10;

zaś poniższy już nie:

final int days = 5;
days = 10; // tutaj będzie błąd!

Operatory

Na zmiennych możemy wykonywać różne operacje, np. arytmetyczne. Robimy to za pomocą operatorów.

Podstawowymi operatorami są znaki “+”, “-”, “*”, “/” oraz “%” oznaczające operację odpowiednio dodawania, odejmowania, mnożenia, dzielenia oraz modulo (reszta z dzielenia). Także znak “=” jest tak zwanym operatorem przypisania. Poniżej przykład użycia tych operatorów:

package pl.kodolamacz;

public class MyFirstJavaApplication {

    public static void main(String[] args) {

        double x = 10;
        double y = 2;

        var result = x + y;
        System.out.println(result);

        result = x - y;
        System.out.println(result);

        result = x * y;
        System.out.println(result);

        result = x / y;
        System.out.println(result);
        
        result = x % y;
        System.out.println(result);
    }

}

Czasami chcemy zwiększyć wartość naszej zmiennej bez konieczności zapisywania wyniku w innej zmiennej jak poniżej:

int x = 2;
int y = x + 5;

Wolimy wtedy napisać:

int x = 2;
x = x + 5;

Można to jednak jeszcze bardziej uprościć używając operatorów “+=”, “-=”, “*=”, “/=”. Dzięki nim zamiast pisać:

package pl.kodolamacz;

public class MyFirstJavaApplication {

    public static void main(String[] args) {

        double x = 10;
        double y = 2;

        x = x + y;
        System.out.println(x);

        x = x - y;
        System.out.println(x);

        x = x * y;
        System.out.println(x);

        x = x / y;
        System.out.println(x);
    }

}

możemy napisać zwięźlej:

package pl.kodolamacz;

public class MyFirstJavaApplication {

    public static void main(String[] args) {

        double x = 10;
        double y = 2;

        x += y;
        System.out.println(x);

        x -= y;
        System.out.println(x);

        x *= y;
        System.out.println(x);

        x /= y;
        System.out.println(x);
    }

}

Zauważmy, że w obydwu przypadkach przy każdym działaniu zmieniamy wartość zmiennej “x”, dlatego wyniki będą inne, niż gdy korzystaliśmy ze zmiennej “result”.

Innymi przydatnymi i często używanymi operatorami są operatory inkrementacji “++” i dekrementacji “–” czyli zwiększenia i zmniejszenia zmiennej o wartość równą jeden. Poniżej krótki przykład użycia tych operatorów:

package pl.kodolamacz;

public class MyFirstJavaApplication {

    public static void main(String[] args) {

        double x = 10;
        System.out.println(x);

        x++;
        System.out.println(x);

        x--;
        System.out.println(x);
        
    }

}

Możemy także zapisać je tak:

package pl.kodolamacz;

public class MyFirstJavaApplication {

    public static void main(String[] args) {
        double x = 10;
        System.out.println(x);
        System.out.println(x++);
        System.out.println(x--);
        System.out.println(x);
    }

}

Niestety po uruchomieniu powyższego programu wyniki, które zobaczymy w terminalu mogą się różnić od tych, których byśmy się spodziewali. Dzieje się tak dlatego, że nasze zmienne zostaną najpierw przekazane do funkcji println i wyświetlone, a dopiero potem zostaną zastosowane operatory “++” i “–”. Gdybyśmy chcieli najpierw wykonać operacje inkrementacji i dekrementacji powinniśmy użyć tych operatorów z lewej strony zmiennej, co będzie oznaczało dla kompilatora “najpierw zwiększ, potem wyślij do funkcji println”. Poniżej przykład:

package pl.kodolamacz;

public class MyFirstJavaApplication {

    public static void main(String[] args) {
        double x = 10;
        System.out.println(x);
        System.out.println(++x);
        System.out.println(--x);
        System.out.println(x);
    }

}

Ostatnimi podstawowymi i często używanymi operatorami są operator równości “==”, operator nierówności “!=” i cztery operatory większości “>”, “<”, “>=”, “<=”, pozwalające sprawdzić czy wartości dwóch zmiennych są równe, czy nie oraz która wartość jest większa. Operatory te zwracają prawdę (true) lub fałsz (false) czyli zmienną typu boolean. Poniżej przykład użycia tych operatorów:

package pl.kodolamacz;

public class MyFirstJavaApplication {

    public static void main(String[] args) {
        double x = 10;
        double y = 5;

        System.out.println(x == y); // czy x jest równe y
        System.out.println(x != y); // czy x jest różne od y

        System.out.println(x > y); // czy x jest większe od y
        System.out.println(x >= y); // czy x jest większe lub równe y

        System.out.println(x < y); // czy x jest mniejsze od y
        System.out.println(x <= y); // czy x jest mniejsze lub równe y
    }

}

Należy pamiętać, że operatory równości działają dla typów prostych. Dla typów złożonych, o których powiemy sobie w kolejnym wyzwaniu, mają zupełnie inne zastosowanie niż “porównanie wartości”. Jest to bardzo ważne, by o tym pamiętać. Dla przykładu takim typem złożonym jest poznany wcześniej String czyli łańcuch znaków. Jeśli chcemy porównać dwa łańcuchy, musimy użyć funkcji equals. Poniżej przykład porównania dwóch napisów:

package pl.kodolamacz;

public class MyFirstJavaApplication {

    public static void main(String[] args) {
        String text = "To jest dowolny tekst";
        var otherText = "To jest inny tekst";

        System.out.println(text.equals(otherText)); // Zwróci false, gdyż napisy są różne
    }

}

Operatory te są używane przede wszystkim w instrukcjach sterujących (patrz dalej).

Więcej operatorów możemy znaleźć pod adresem: https://docs.oracle.com/javase/tutorial/java/nutsandbolts/operators.html. Zamieszczona tam tabela nie tylko pokazuje wszystkie dostępne operatory w języku Java, ale także odzwierciedla kolejność wykonywania operacji gdy w jednej linijce kodu użyjemy kilku operatorów, podobnie jak w szkole podstawowej na lekcjach matematyki słuchaliśmy o kolejności wykonywania działań matematycznych. Tak samo jak na matematyce, w Javie także można się wspomagać nawiasami, gdy domyślna kolejność nam nie odpowiada.

Instrukcje warunkowe

W Javie, podobnie jak w większości języków programowania, działaniem naszego programu sterujemy za pomocą instrukcji warunkowych. Do budowania tych instrukcji korzystamy ze słówka kluczowego if oraz else.

W najprostszej postaci instrukcja warunkowa wygląda tak:

if (warunek) polecenie;

Jeśli chcemy dla danego warunku wykonać kilka instrukcji musimy użyć nawiasów { }:

if (warunek) {
    instrukcja 1;
    instrukcja 2;
}

Instrukcje wewnątrz nawiasów { } nazywamy blokiem instrukcji.

Gotowy kod Java może więc wyglądać tak:

package pl.kodolamacz;

public class MyFirstJavaApplication {

    public static void main(String[] args) {
        double x = 10;
        double y = 5;

        if(x > y){
            System.out.println("x jest większe od y");
        }
    }

}

Funkcja println zostanie wykonana tylko i wyłącznie wtedy, gdy wartość zmiennej x będzie większa od y (co w tym przypadku jest prawdą).

Jeśli chcemy wykonać jakąś akcję gdy warunek nie zostanie spełniony możemy użyć słowa kluczowego else:

package pl.kodolamacz;

public class MyFirstJavaApplication {

    public static void main(String[] args) {
        double x = 10;
        double y = 5;

        if(x > y){
            System.out.println("x jest większe od y");
        } else {
            System.out.println("x nie jest większe od y");
        }
    }

}

Instrukcję if można łączyć ze sobą robiąc kaskadę warunków:

package pl.kodolamacz;

public class MyFirstJavaApplication {

    public static void main(String[] args) {
        double x = 10;
        double y = 5;

        if(x > y){
            System.out.println("x jest większe od y");
        } else if (x < y) {
            System.out.println("x jest mniejsze od y");
        } else {
            System.out.println("x jest równe y");
        }
    }

}

Pętle

Innym mechanizmem sterowania pracą naszego programu są pętle. Pozwalają one na wykonanie wielokrotnie jakiejś operacji. W składni języka mamy dostępne trzy rodzaje pętli: while, do-while oraz for, która jest dostępna w dwóch wariantach.

Pętla while służy do wykonywania jakiejś instrukcji dopóki spełniony jest warunek:

while (warunek) instrukcja

Tak samo jak w przypadku instrukcji warunkowych możemy w pętli wykonywać całe bloki kodu dzięki nawiasom { }.

Poniższy program pobiera od użytkownika liczbę dopóki jej wartość nie będzie większa od 100:

package pl.kodolamacz;

import java.util.Scanner;

public class MyFirstJavaApplication {

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);

        System.out.println("Podaj proszę liczbę większą od 100:");
        var number = scanner.nextDouble();

        while (number <= 100) {
            System.out.println("Liczba nie jest większa od 100, podaj jeszcze raz:");
            number = scanner.nextDouble();
        }

        scanner.close();

        System.out.println("Dziękuję! Podałeś liczbę: " + number);
    }

}

Jeśli zmienna number już za pierwszym razem zostanie podana prawidłowa, nasza pętla nigdy się nie wykona, gdyż najpierw jest sprawdzany warunek.

Pętla do-while działa bardzo podobnie do *while, jednak w tym przypadku najpierw wykonujemy blok kodu, a dopiero potem sprawdzamy warunek. Nasz program z użyciem pętli do-while będzie wyglądać tak:

package pl.kodolamacz;

import java.util.Scanner;

public class MyFirstJavaApplication {

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);

        double number;
        do {
            System.out.println("Podaj proszę liczbę większą od 100:");
            number = scanner.nextDouble();
        } while (number <= 100);

        scanner.close();

        System.out.println("Dziękuję! Podałeś liczbę: " + number);
    }

}

Pętla for służy do wykonania jakiejś instrukcji określoną liczbę razy. Jej składnia wygląda następująco:

for ( inicjalizacja zmiennych pomocniczych; warunek ; zmiana wartości zmiennych pomocniczych)
    instrukcja

Wyobraźmy sobie, że chcemy wyświetlić wszystkie liczby od 1 do 10. Nasz program z użyciem pętli while wyglądałby tak:

package pl.kodolamacz;

public class MyFirstJavaApplication {

    public static void main(String[] args) {

        var i = 1;
        while (i <= 10) {
            System.out.println(i++);
        }
    }

}

zaś w przypadku pętli for tak:

package pl.kodolamacz;

public class MyFirstJavaApplication {

    public static void main(String[] args) {

        for (var i = 1; i <= 10; i++) {
            System.out.println(i);
        }
    }

}

Jak widać na dwóch powyższych przykładach, obydwu pętli można stosować zamiennie w zależności od tego, której w danym momencie jest nam łatwiej użyć!

Pętla for ma jeszcze drugą wersję, tak zwany foreach, ale do tego przypadku wrócimy gdy poznamy tablice i kolekcje w Javie.

Wyzwanie

Nasze drugie wyzwanie będzie bardziej wymagające od poprzedniego. Chcemy byście napisali uproszczoną wersję kalkulatora! Uproszczoną dlatego, że nie będziemy mieć okienka z przyciskami, liczby jak i polecenia będziemy podawać w terminalu, np. tak:

Proszę podaj w oddzielnych linijkach jakąś liczbę, operację matematyczną +,-,*,/,%, a następnie kolejną liczbę:
12
+
3
Twój wynik to: 15
Chcesz wykonać kolejne działanie? Wpisz literę t lub n.

Legenda

Wprowadzenie do świata języka Java

Fri, 20 Apr 2018 00:00:00 +0000

Wiele początkujących osób zadaje sobie pytanie:

Jaki język programowania wybrać na początek i dlaczego?

W tym poście spróbuję odpowiedzieć dość szeroko na to pytanie :)

Języki programowania

Programowanie to tak naprawdę rozmowa z komputerem, przekazywanie mu naszych poleceń, które on będzie wykonywać. Jednak do tego potrzebny jest odpowiedni język, który maszyna, czytaj komputer, zrozumie. Takich języków powstało naprawdę wiele. Niektóre są proste i łatwe, inne znowu wyrafinowane i zarazem skomplikowane. Każdy z języków ma swoje zalety i wady, stąd jest ich tak wiele - by można było wybrać taki, który najbardziej będzie się nadawał do naszego zadania lub taki, który będzie dla nas bardziej przyjazny.

Trzeba też pamiętać, że nie każdy język programowania służy do tego samego. Języki takie jak HTML, CSS czy JavaScript (nie mylić z Javą!) służą przede wszystkim do tworzenia stron internetowych i są zrozumiałe dla przeglądarek internetowych takich jak Firefox, Chrome czy Edge. Z drugiej strony bardzo popularny język SQL (ang. Structured Query Language) jest językiem służącym do komunikacji z bazami danych, czyli programami służącymi do przechowywania informacji zgodnie z określonymi regułami. Język PHP jest bardzo popularny w zastosowaniach serwerowych służących do generowania dynamicznie naszych stron internetowych (w przeciwieństwie do HTML, CSS i Javascript nie działa po stronie przeglądarki internetowej tylko serwera). Języki takie jak C, C++ czy C# bardzo często używane są do tworzenia aplikacji okienkowych, najprawdopodobniej większość waszych aplikacji zainstalowanych w komputerze jest stworzona w oparciu o te języki programowania. Oczywiście to tylko przykłady, języków programowania jest dużo więcej oraz ich zastosowania bywają szersze niż wskazane powyżej.

Język Java

My zachęcamy Was do rozpoczęcia swojej przygody w językiem Java. Jest to obecnie jeden z popularniejszych języków programowania, bardzo wszechstronny i zarazem wydajny.

Historia

Prace nad stworzeniem języka Java rozpoczęły się już w 1991 roku. Autorami projektu byli James Gosling, Mike Sheridan, i Patrick Naughton. Początkowo język nazywał się Oak po drzewie o tej samej nazwie, co w języku polskim oznacza Dąb. Inspiracja pochodziła od drzewa, które rosło obok gabinetu James’a Gosling’a, uznawanego obecnie za ojca języka Java. Sam projekt, w ramach którego powstał ten język, nosił kryptonim Green. Następnie z powodu zastrzeżenia nazwy przez Oak Technologies, język zyskał nazwę Java pochodzącą od kawy z wyspy Jawa w Indonezji (ang. Java coffee, https://www.javaworld.com/article/2077265/core-java/so-why-did-they-decide-to-call-it-java-.html).

Informacja o stworzeniu języka Java została podana publicznie 23 maja 1995 roku, zaś pierwsza wersja do ściągnięcia ukazała się 23 stycznia 1996 roku (http://oracle.com.edgesuite.net/timeline/java/). Obecnie najnowsza wersja języka Java opatrzona jest numerem 10 i została wydana 20 marca 2018 roku, zaś kolejne mają ukazywać się co pół roku.

Za powstaniem języka Java stoi firma Sun Microsystems (skrót od Stanford University Network), producent sprzętu i oprogramowania komputerowego oraz rozwiązań sieciowych. 27 stycznia 2010 roku Sun został przejęty przez firmę Oracle, która jest drugim na świecie, po firmie Microsoft, sprzedawcą oprogramowania (https://www.pwc.com/gx/en/industries/technology/publications/global-100-software-leaders/explore-the-data.html).

Cechy języka Java

Składnia języka Java bazuje na jednym z najpopularniejszych w tamtych czasach języku programowania jakim był C++, dzięki czemu była bardzo łatwa do nauki dla dużego grona programistów oraz była od razu językiem obiektowym. Jednak w przeciwieństwie do języka C++, Java miała być dużo łatwiejsza do tworzenia oprogramowania, przez co miała skrócić czas niezbędny na napisanie programu. Osiągnięto to przede wszystkim przez wprowadzenie prostszego i automatycznego zarządzania pamięcią. Programiści nie muszą już samodzielnie zwalniać pamięci dzięki wprowadzeniu narzędzia zwanego Garbage Collector oraz nie mają możliwości korzystania ze wskaźników do pamięci operacyjnej, które sprzyjały nadpisywaniu trzymanych tam informacji, a tym samym awariom programu czy utratom danych. W języku Java wprowadzono także wiele uproszczeń w składni względem języka C++. Celem twórców było stworzenie języka, który miał być prostszą wersją języka C++ z zachowaniem wszystkich zalet takich jak np. bardzo duża wydajność.

Początkowo Java miała być wykorzystywana do tworzenia oprogramowania dla urządzeń telewizyjnych, gdzie wcześniej używany był głównie język C++. Niestety wymagało to często tworzenia dedykowanego kodu na każde urządzenie, dlatego główną ideą, która przyświecała twórcom Javy, była “Write Once, Run Anywhere”, czyli napisz raz swój program i uruchamiaj gdziekolwiek. Tak powstała maszyna wirtualna Java umożliwiająca uruchamianie wszędzie tego samego kodu napisanego w języku Java. Możliwość uruchamiania programów na wielu systemach i urządzeniach nazywamy także multiplatformowością.

Trzecią ważną ideą, która przyświecała twórcom języka Java, poza automatycznym zarządzaniem pamięcią oraz uruchamianiem tego samego programu na wielu platformach, miała być uniwersalność języka. Java miała się stać językiem wszechstronnym, w którym można pisać aplikacje okienkowe, serwerowe, internetowe, mobilne oraz w dalszym ciągu umożliwiać tworzenie oprogramowania dla urządzeń, tak zwanych systemów wbudowanych (https://pl.wikipedia.org/wiki/System_wbudowany). Java jest również językiem, który sprzyja wykorzystaniu go w warunkach sieciowych dzięki dużemu bezpieczeństwu i wbudowanym mechanizmom obsługi komunikacji sieciowej.

Popularność

W internecie bardzo łatwo znaleźć serwisy, które za pomocą wielu różnych metod próbują oszacować popularność języków programowania. Do najpopularniejszych należą:

Jak widać z powyższych statystyk, Java jest czołowym językiem programowania wykorzystywanym od lat.

Zastosowania

O popularności języka Javy zdecydowała w dużej mierze jego wszechstronność. Możemy z jego pomocą tworzyć aplikacje okienkowe, serwerowe, mobilne (np. na systemie Android), a nawet spotkać programy napisane w tym języku w urządzeniach takich jak telewizory, odtwarzacze Blu-Ray czy karty chipowe.

Wydajność

Język Java dzięki wielu optymalizacjom jest jednym z wydajniejszych języków programowania o czym możemy się przekonać analizując wyniki testów zamieszczonych na stronie: https://benchmarksgame.alioth.debian.org/.

Możliwości

Język Java oferuje wiele możliwości swoim użytkownikom. Jest przede wszystkim językiem obiektowym, ale od wersji 8 języka Java możemy także programować w nim funkcyjnie. O obiektowości i funkcyjności języka Java będziemy mówić w oddzielnych wyzwaniach. Java jest też językiem wielowątkowym, czyli takim który umożliwia wykonywanie wielu poleceń na raz (równolegle na wielu rdzeniach procesora).

Wirtualna maszyna Java

Java to język programowania. To już wiemy. Ale to nie wszystko. Java to także wirtualna maszyna Java (ang. Java Virtual Machine, w skrócie JVM) na której możemy uruchamiać programy napisane w języku Java i nie tylko w tym języku! Obecnie na JVM można uruchamiać wiele innych języków. Do najpopularniejszych z nich należą: Scala, Kotlin, Groovy, Clojure oraz języki, które nie powstały z myślą o pracy w wirtualnej maszynie Java, lecz zostały później zaadaptowane jak np. Ruby (JRuby), Python (Jython).

Platforma Java

Oprócz języków programowania i maszyny wirtualnej, często mówimy także o “platformach” dostępnych dla środowiska Java. Do tych platform należą:

Java Standard Edition (Java SE) - aplikacje uruchamiane w konsoli lub aplikacje okienkowe
Java Enterprise Edition (Java EE) - aplikacje serwerowe
Java Micro Edition (Java ME) - aplikacje mobilne lub działające na urządzeniach o niskiej wydajności
Java FX - aplikacje RIA (rich internet applications) oraz aplikacje okienkowe
Java Card - mikro aplikacje uruchamiane na kartach elektronicznych

Platforma Java to tak naprawdę zbiór bibliotek i narzędzi umożliwiających lub ułatwiających tworzenie oprogramowania dla konkretnych zastosowań, np. aplikacje serwerowe w Java EE.

Java oraz Kotlin są także językami używanymi do pisania aplikacji mobilnych na systemie Android tworzonego przez firmę Google (https://developer.android.com/samples/index.html).

Społeczność

Java to również, a może przede wszystkim, olbrzymia społeczność programistów z całego świata, którzy nie tylko pomagają sobie wzajemnie, ale także dzielą się swoim oprogramowaniem na zasadach Open Source, czyli otwartego kodu. Najpopularniejsze biblioteki i narzędzia tworzone są przez fundację Apache (http://www.apache.org/). Wiele też firm tworzy swoje oprogramowanie i udostępnia je innym firmom i programistom za darmo lub na podstawie płatnych licencji. Jednym z najpopularniejszych portali gdzie możemy znaleźć ogromną ilość oprogramowania i bibliotek napisanych w języku Java (oraz innych używanych na JVM), dostępnych na zasadach otwartego kodu źródłowego, jest portal GitHub (https://github.com/).

Język Java, maszyna wirtualna Java oraz platformy Java są również tworzone przez społeczność. Właścicielem praw do języka Java jest firma Oracle. Mimo to, sam proces wprowadzania nowych zmian i funkcjonalności realizowany jest przez społeczność programistów i firm z całego świata w ramach procesu zwanego Java Community Process, JCP (https://jcp.org). Listę zaangażowanych firm można znaleźć pod adresem: https://jcp.org/en/participation/members/. Wśród nich możemy odnaleźć takie firmy jak Google, Hewlett Packard Enterprise, Intel Corp, Twitter, Red Hat, IBM, Fujitsu Limited oraz wiele, wiele innych. Zmiany wprowadzane są w postaci tak zwanych Java Specification Requests, JSR, które podlegają ocenie i głosowaniu. Cały proces opisany jest pod adresem: https://jcp.org/en/procedures/overview.

Oracle Java vs Microsoft .NET

Niewiarygodny sukces platformy Java przyczynił się także do powstania w 2002 roku konkurencyjnej platformy autorstwa firmy Microsoft zwanej platformą .NET (pełna nazwa .NET Framework). Początkowo twórcy zaimplementowali własną wersję języka Java z lekkimi modyfikacjami pod nazwą J++, zaś później stworzyli swój własny język, konkurencyjny do języka Java, który nazwali C#. Platforma firmy Microsoft była początkowo rozwijana tylko na systemy firmy Microsoft, jednak 27 czerwca 2016 roku została wydana zupełnie nowa wersja platformy .NET pod nazwą .NET Core, która w odróżnieniu od .NET Framework jest multiplatformowa (Windows, Linux, MacOS) oraz otwartoźródłowa.

A na koniec coś na poprawę humoru :)

Legenda:

Wyzwanie Java #1: Hello World! - rozwiązanie

Fri, 20 Apr 2018 00:00:00 +0000

W poprzednim wyzwaniu poprosiliśmy Was o napisanie programu, który wyświetla prośbę o podanie imienia i następnie nazwiska, pobiera te dwa napisy od użytkownika, a następnie wyświetla obydwa jak w przykładzie poniżej:

Proszę podaj swoje imię:
Jan
Proszę podaj swoje nazwisko:
Kowalski
Witaj Jan Kowalski

W poście na FB z rozwiązaniami zamieściliście już kilkadziesiąt rozwiązań. Wierzymy, że osób które przystąpiły do wyzwania jest jeszcze więcej. Tych którzy jeszcze nie zmierzyli się z naszym zadaniem zachęcamy by to jeszcze zrobili w ten weekend!

Wszystkie rozwiązania były prawidłowe, choć kod od siebie się różnił, co pokazuje pewną wspaniałą rzecz w programowaniu, często ten sam problem możemy rozwiązać na wiele różnych sposobów i wszystkie będą prawidłowe!

Poniżej przykładowe i zarazem najpopularniejsze rozwiązanie wyzwania:

package pl.kodolamacz;

import java.util.Scanner;

public class MyFirstJavaApplication {

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);

        System.out.println("Proszę podaj swoje imię:");
        String forename = scanner.nextLine();

        System.out.println("Proszę podaj swoje nazwisko:");
        String surname = scanner.nextLine();

        scanner.close();

        System.out.println("Witaj " + forename + " " + surname);
    }

}

Kolejne wyzwanie w poniedziałek 23 kwietnia o 10:00. Podwyższamy poprzeczkę i wprowadzimy sporo nowych rzeczy związanych z językiem Java, w tym nowości z JDK 10! Zaplanujcie sobie trochę wolnego czasu na przyszły tydzień na nasze wyzwanie :)

Wyzwanie Java #1: Hello World!

Mon, 16 Apr 2018 00:00:00 +0000

Jak już wiecie, chcemy Was zachęcić i zmotywować do nauki programowania! Do rozpoczęcia tej przygody potrzebny będzie nam komputer, dostęp do internetu i dużo, dużo chęci i wytrwałości :)

Naszym pierwszym wyzwaniem będzie napisanie swojego pierwszego programu w Javie!

Przygotujmy się

Zanim zaczniemy cokolwiek programować musimy przygotować nasz komputer do pracy. Będziemy potrzebować na początek wirtualnej maszyny Java (ang. Java Virtual Machine, w skrócie JVM) oraz środowiska dla programistów, tak zwane zintegrowane środowisko programistyczne (ang. integrated development environment, w skrócie IDE).

Wirtualna Maszyna Java

Java to jeden z najpopularniejszych języków programowania na świecie. Jednak Java, to nie tylko język programowania, to także cały ekosystem technologii i języków programowania zorientowanych wokół tak zwanej wirtualnej maszyny Java, czyli środowiska uruchomieniowego, które musimy zainstalować w naszym systemie operacyjnym (np. Windows, Linux, macOS) lub innym dowolnym urządzeniu, na którym chcemy wykonywać nasze programy. Taką maszynę wirtualną znajdziemy na większości komputerach na świecie, telefonach z systemem Android czy nawet na odtwarzaczach Blu-ray. Według strony https://go.java/ obecnie już około 15 miliardów urządzeń korzysta z Javy.

Dlatego zanim zaczniemy cokolwiek robić w Javie, potrzebujemy zainstalować sobie wirtualną maszynę Java, która jest udostępniana w dwóch wersjach; Java Runtime Environment (JRE) zawierająca podstawową instalację maszyny wirtualnej wraz z dodatkowymi bibliotekami i komponentami, służącą przede wszystkim do uruchamiania programów oraz Java Development Kit (JDK) zawierająca wszystko co ma JRE plus dodatkowe narzędzia dla programistów. My oczywiście będziemy potrzebować JDK, które możemy ściągnąć ze strony: http://www.oracle.com/technetwork/java/javase/downloads/index.html

Poniżej proces instalacji jdk wersji 10 na systemie Windows:

Zintegrowane środowisko programistyczne

Programowanie w skrócie to tak naprawdę pisanie odpowiednich poleceń w wybranym języku programowania które to polecenia są następnie tłumaczone na instrukcje rozumiane przez komputer, tak zwany kod maszynowy. Tak naprawdę nasz kod, czyli zestaw tych poleceń, możemy pisać w dowolnym narzędziu, począwszy od notatnika. Takie pisanie niestety wymaga od nas dużo większego wysiłku, dlatego z pomocą przychodzą właśnie zintegrowane środowiska programistyczne, które zawierają szereg ułatwień jak podpowiadanie składki, sprawdzanie poprawności naszego programu czy łatwiejsze testowanie.

Najpopularniejszymi IDE dla Javy są:

IntelliJ IDEA https://www.jetbrains.com/idea/
Eclipse http://www.eclipse.org
NetBeans https://netbeans.org

To które środowisko wybierzemy zależy tak naprawdę od nas, czyli naszych predyspozycji. Z naszej strony polecamy wybranie IntelliJ IDEA i z tego narzędzia będziemy korzystali w przykładach. Oczywiście wystarczy nam darmowa wersja Community.

Poniżej proces instalacji IntelliJ IDEA na systemie Windows:

Pierwszy program

Mając już JDK i wybrane IDE możemy przystąpić do napisania swojego pierwszego programu w języku Java.

Po pierwszym uruchomieniu IDEI powinniśmy zobaczyć okno z wyborem kolorystyki. Wybór według własnych preferencji.

W następnym okienku możemy wybrać różne ustawienia i dodatki - zostawmy te domyślne.

Tutaj również zostawiamy ustawienia domyślne i klikamy “Start using IntelliJ IDEA”.

Pojawia nam się okno startowe:

Wybieramy opcję “Create New Project”.

W nowo otwartym oknie musimy wskazać IDEI lokalizację naszego SDK, klikamy “New” i wybieramy miejsce instalacji SDK w naszym systemie (w przypadku systemu Windows będzie to C:\Program Files\Java\jdk-10). Następnie klikamy dwukrotnie “Next”.

W kolejnym oknie musimy wpisać nazwę naszego projektu, podajemy “kodolamacz-first-challenge” i klikamy “Finish”.

Otworzyło nam się główne okno IDEI z naszym projektem.

To jednak tylko pusty projekt. Teraz musimy napisać swój pierwszy kawałek kodu. W tym celu rozwijamy drzewo z lewej strony z nazwą naszego projektu i na katalogu “src” klikamy prawym przyciskiem myszy i wybieramy opcję “New” a następnie “Java Class”. W nowo otwartym oknie jako nazwę wpisujemy “pl.kodolamacz.MyFirstJavaApplication” i klikamy “Ok”

W rezultacie dostajemy poniższy kod:

package pl.kodolamacz;

public class MyFirstJavaApplication {
}

Czym są klasy Java dowiemy się później, na razie potraktujmy je jako sposób organizacji kodu, czyli naszych poleceń, w świecie Java. Klasy będą się znajdować w plikach z rozszerzeniem .java.

W aktualnej wersji nasz kod jeszcze nic nie robi, to tylko szablon. Najprostszą operacją jaką możemy kazać wykonać komputerowi jest wyświetlenie napisu. By tego dokonać należy najpierw dodać tak zwaną metodę main którą można uruchomić, czyli coś w rodzaju punktu startowego naszego programu. Nasz kod powinien wyglądać tak:

package pl.kodolamacz;

public class MyFirstJavaApplication {

    public static void main(String[] args) {
        
    }
    
}

Teraz możemy skorzystać z funkcji println:

package pl.kodolamacz;

public class MyFirstJavaApplication {

    public static void main(String[] args) {
        System.out.println("Witaj świecie!");
    }

}

Funkcja println wyświetla dowolny ciąg znaków na tak zwanym standardowym wyjściu. Jest to jeden z możliwych sposobów komunikacji z naszym programem. Więcej o strumieniach możemy przeczytać na Wikipedii: https://pl.wikipedia.org/wiki/Standardowe_strumienie. Żeby skorzystać ze standardowego wyjścia musimy skorzystać z klasy System służącą między innymi do obsługi standardowych strumieni w Javie. W tej klasie możemy skorzystać z pola out gdzie mamy dostępną funkcję println. Temat pól w klasach (ang. field) także zostanie szczegółowo omówiony w kolejnych naszych wydarzeniach.

Teraz czas najwyższy by uruchomić nasz program! Klikamy w dowolnym miejscu naszego kodu prawym przyciskiem myszki i wybieramy opcję “Run ‘MyFirstJavaApplication….main()’” lub naciskamy kombinację klawiszy Ctrl+Shift+F10. Na dole ekranu powinniśmy zobaczyć wynik wykonania naszego programu, czyli oczekiwany napis:

Witaj świecie!

Process finished with exit code 0

Jeśli napis się nie wyświetlił, trzeba sprawdzić czy wszystkie nawiasy i średniki są na swoim miejscu.

Gratulacje! Udało Ci się napisać i uruchomić swój pierwszy program w języku Java. Jest to tak zwany “Hello world” (https://pl.wikipedia.org/wiki/Hello_world) czyli program wyświetlający napis “Witaj świecie” i najczęściej właśnie od takiego programu zaczynamy naukę nowego lub nawet pierwszego języka programowania lub biblioteki.

Jednak na tym nie skończymy. Do wyświetlenia napisu “Witaj świecie” użyliśmy standardowego wyjścia. Teraz użyjemy standardowego wejścia, żeby pobrać od użytkownika jakiś napis:

package pl.kodolamacz;

import java.util.Scanner;

public class MyFirstJavaApplication {

    public static void main(String[] args) {
        System.out.println("Witaj świecie!");

        Scanner scanner = new Scanner(System.in);
        String userString = scanner.nextLine();
        scanner.close();

        System.out.println("Twój napis to: " + userString);
    }

}

Wykorzystaliśmy do tego klasę Scanner przekazując do niej standardowe wejście (System.in). W klasie Scanner mamy metodę nextLine() która pozwala nam odczytać linijkę tekstu wpisanego przez użytkownika. Następnie przypisujemy tą linijkę do zmiennej userString i wyświetlamy na standardowym wyjściu. Zmiennym poświęcimy następne wyzwania, na ten moment załóżmy, że jest to jakiś pojemnik na dane tekstowe, które w świecie Javy oznaczamy jako String.

Gdy uruchomimy nasz program i wpiszemy jakąś linię tekstu (pod napisem Witaj świecie, np. odpowiedź “Witaj”) potwierdzając to klawiszem Enter, program powinien wyświetlić nam wpisaną linijkę tekstu jak poniżej:

Witaj świecie!
Witaj
Twój napis to: Witaj

Process finished with exit code 0

Wyzwanie

Teraz zadanie dla Was! Korzystając ze standardowych strumieni w Javie i zdobytej wiedzy napiszcie program, który wyświetla prośbę o podanie imienia i następnie nazwiska, pobiera te dwa napisy od użytkownika, a następnie wyświetla obydwa jak w przykładzie poniżej:

Proszę podaj swoje imię:
Jan
Proszę podaj swoje nazwisko:
Kowalski
Witaj Jan Kowalski

Wyzwanie: Naucz się programowania w Javie od postaw!

Tue, 03 Apr 2018 00:00:00 +0000

Żyjemy w cyfrowym świecie. Gdzie nie spojrzeć otaczają nas maszyny i urządzenia elektroniczne ułatwiające nam życie. Praktycznie każdy z nas korzysta z komputerów, smartfonów, tabletu czy czytnika ebook’ów. W garażu mamy samochody z komputerami pokładowymi, w kuchni programowalne lodówki i piekarniki, w salonie telewizor z systemem operacyjnym zaś po pokoju jeździ automatyczny odkurzacz. Z roku na rok nasze urządzenia się coraz bardziej skomplikowane i coraz więcej potrafią. Jednak do pracy, urządzenia elektroniczne potrzebują odpowiedniego oprogramowania czyli zestawu reguł, poleceniem które mówią mu co mają robić. Czasami są to bardzo proste instrukcje sterujące, innym razem skomplikowane algorytmy starające się naśladować ludzki mózg.

Jednak by ten postęp miał miejsce potrzebni są ludzie którzy je tworzą, inżynierowie i programiści których w związku z ciągłym postępem technologicznym ciągle brakuje. Dlatego chcielibyśmy Was zachęcić do nauki programowania. Nie każdy musi zostać od razu programistą, ale w obecnym świecie warto uczyć się programowania choćby po to by zrozumieć technologię która nas otacza. Dlatego coraz częściej mówi się o tym by programowania uczyć już najmłodszych:

Poniżej film (wersja anglojęzyczna) pokazujący dlaczego warto uczyć programowania już w szkole:

W kolejnym filmiku możemy dowiedzieć się na czym polega programowanie:

Poniżej film nagrany przez Krzysztofa Gonciarza, jednego z najpopularniejszych polskich Youtuberów o tym czy warto programować.

Jeśli podobały się Wam powyższe filmy i chcielibyście dowiedzieć się na czym polega właśnie to programowanie, chcielibyśmy rzucić Wam WYZWANIE do nauki programowania. W ciągu najbliższych kilku tygodni będziemy zamieszczać na naszym profilu tak zwane wyzwania programistyczne, których celem będzie zachęcenie Was do nauki programowania w języku Java. Każde takie wyzwanie będzie zawierać odnośnik do materiałów, gdzie znajdziecie odpowiednią wiedzę oraz zadanie do wykonania. Po każdym wyzwaniu liczymy na informację zwrotną czy się udało lub o problemach które napotkaliście, byśmy mogli Wam pomóc je rozwiązać.

Do udziału zachęcamy wszystkich, którzy nigdy nie programowali i chcą zobaczyć na czym to polega, jak i te osoby, które już zaczęły swoją przygodę z programowaniem, ale z innym językiem programowania niż Java lub chcą uzupełnić swoją wiedzę.

Lista artykułów:

Artykuły dodatkowe:

Linki do wydarzenia na FB:

Jak sprawdzić jakiej wersji Linux'a używamy

Tue, 20 Mar 2018 21:27:14 +0100

W tym poście zbiór poleceń pozwalających sprawdzić jakiej wersji systemu używamy. Przydatne gdy chcemy doinstalować dodatkowe oprogramowanie.

Debian / Ubuntu / Mint

Zaczynamy od najpopularniejszej według https://distrowatch.com/ gałęzi systemów opartych o dystrybucję Debian:

Wydania Debiana: https://wiki.debian.org/DebianReleases
Wydania Ubuntu: https://wiki.ubuntu.com/Releases
Wydania Mint’a: https://linuxmint.com/download_all.php

cat /etc/debian_version
cat /etc/issue

cat /etc/lsb-release
cat /etc/os-release

cat /etc/upstream-release/lsb-release
cat /etc/linuxmint/info

uname -a
lsb_release -a
lsb_release -cs
lsb_release -d

Red Hat / CentOS / Fedora

Teraz kolej na dystrybucje z rodziny Red Hat’a

cat /etc/centos-release
cat /etc/os-release
cat /etc/redhat-release
cat /etc/system-release

hostnamectl
rpm --query centos-release

uname -a
lsb_release -a
lsb_release -cs
lsb_release -d

Instalacja HDP 2.6 na pojedynczej maszynie

Sun, 04 Mar 2018 00:00:00 +0000

W tym poście pokażę jak przygotować sobie jedną wirtualną maszynę z zainstalowaną dystrybucją Hortonworks. Taką maszynę, zwaną sandbox’em możemy wykorzystywać do celów testowych i developerskich.

Stworzenie maszyny wirtualbox i instalacja systemu operacyjnego CentOS 6

Zaczniemy od stworzenia maszyny wirtualnej i instalacji na niej systemu CentOS 6. Opis jak to zrobić można znaleźć tutaj

Przygotowanie systemu operacyjnego CentOS 6

Aktualizacja systemu

Żeby pracować na najnowszej wersji systemu należy go zaktualizować

yum -y update
yum -y upgrade

Instalacja Vim

yum -y install vim

Włączamy automatyczne DHCP

Aby włączyć ręcznie dhcp należy wykonać:

dhclient -v

W celu skonfigurowania tego na stałe warto zmienić wartość (ONBOOT=yes) w pliku /etc/sysconfig/network-scripts/ifcfg-eth0

vim /etc/sysconfig/network-scripts/ifcfg-eth0

Włączamy logowanie root’a po haśle

Ustawiamy parametr (PermitRootLogin yes) w pliku /etc/ssh/sshd_config

vim /etc/ssh/sshd_config

(UWAGA nigdy tego nie róbmy na produkcyjnych serwerach, NIGDY!)

Logowanie po SSH

ssh-copy-id root@localhost -p 2222 ssh root@localhost -p 2222

Zmieniamy hostname

Jeśli podczas instalacji nie ustawiliśmy adresu naszej maszyny możemy zrobić to teraz:

Do pliku /etc/sysconfig/network dodajemy wpis:

NETWORKING=yes
HOSTNAME=sandbox.hortonworks.com

Sprawdzamy za pomocą:

hostname
hostname -f

Polecenie hostname i hostname -f powinny zwracać tą samą wartość.

Warto też ustawić to samo w pliku hosts:

vim /etc/hosts

wartość pliku:

127.0.0.1   sandbox sandbox.hortonworks.com
127.0.0.1   localhost localhost.localdomain localhost4 localhost4.localdomain4
::1         localhost localhost.localdomain localhost6 localhost6.localdomain6

Po tej operacji warto zrestartować system.

Konfiguracja epel release

Dodajemy repozytorium dodatkowych narzędzi systemowych

yum -y install epel-release

Instalacja przydatnych narzędzi

yum -y install wget vim htop ntp openssh-server openssh-clients nano bash-completion tree

Konfiguracja kluczy publicznego i prywatnego

Hadoop do działania wymaga by użytkownik systemowy mógł logować się do innych maszyn bez hasła za pomocą infrastruktury klucza prywatnego i publicznego, dlatego wykonujemy poniższe polecenia: (przy pierwszym naciskamy klawisz Enter kilka razy, przy drugim wybieramy yes i wpisujemy hasło użytkownika root)

ssh-keygen
ssh-copy-id sandbox.hortonworks.com
ssh sandbox.hortonworks.com

Wyłączamy SELINUX

sed -i 's/SELINUX=enforcing/SELINUX=disabled/g' /etc/sysconfig/selinux
sed -i 's/SELINUX=enforcing/SELINUX=disabled/g' /etc/selinux/config

setenforce 0

sestatus

Wyłączamy Firewall’a

chkconfig iptables off
/etc/init.d/iptables stop

Włączamy serwer czasu NTP

yum install -y ntp

chkconfig ntpd on
service ntpd start

Ustawiamy zalecany domyślny umask

umask 0022
echo umask 0022 >> /etc/profile

Na koniec restartujemy maszynę.

Instalacja Apache Ambari

Dodajemy repozytorium Ambari

wget -nv http://public-repo-1.hortonworks.com/ambari/centos6/2.x/updates/2.6.1.3/ambari.repo -O /etc/yum.repos.d/ambari.repo
wget -nv http://public-repo-1.hortonworks.com/HDP/centos6/2.x/updates/2.6.4.0/hdp.repo -O /etc/yum.repos.d/hdp.repo
yum repolist
yum update
yum upgrade

Instalujemy Ambari

yum install ambari-server -y

Konfigurujemy Ambari

(W każdym pytaniu wybieramy odpowiedź domyślną klikając klawisz Enter za każdrym razem)

ambari-server setup

Restartujemy Ambari

ambari-server start

Po tej operacji można zrestartować maszynę. Przed kontynuacją ustawmy naszej maszynie przynajmniej 4 rdzenie oraz przynajmniej 8GB RAM.

Instalacja dystrybucji Hortonworks

Jeśli wszystko poszło jak trzeba, możemy zalogować się do Ambari we własnej przeglądarce pod adresem: http://localhost:8080/

Instalacja sterownika JDBC

yum -y install mysql-connector-java*
ls -al /usr/share/java/mysql-connector-java.jar
cd /var/lib/ambari-server/resources/
ln -s /usr/share/java/mysql-connector-java.jar mysql-connector-java.jar

Instalacja środowiska graficznego

Instalacja pakietów i narzędzi

yum -y groupinstall "X Window System"
yum -y groupinstall "Desktop"
yum -y groupinstall "General Purpose Desktop"
yum -y groupinstall "Desktop Platform"
yum -y groupinstall "Graphical Administration Tools"
yum -y groupinstall "Fonts"
yum -y groupinstall "Internet Browser"

Instalacja przydatnych narzędzi

yum -y install gnome-system-monitor firefox htop git vim mc gedit wget

Instalacja dodatków dla Virtualbox Guest

yum -y install kernel*
yum -y install gcc kernel-devel kernel-headers dkms make bzip2 perl

Dodawanie użytkownika

adduser sages
passwd sages

Restartujemy maszynę

Uruchomienie trybu graficznego

startx

Legenda

https://docs.hortonworks.com/HDPDocuments/Ambari-2.5.1.0/bk_ambari-installation/content/ambari_repositories.html

Ambari i biblioteka libtirpc-devel

Fri, 17 Nov 2017 19:09:57 +0100

Podczas instalacji Ambari na najnowszych platformach CentOS / Red Hat możemy dostać błąd podobny do poniższego:

2017-11-17 13:04:44,147 - Execution of '/usr/bin/yum -d 0 -e 0 -y install hadoop_2_6_3_0_235-client' returned 1. Error: Package: hadoop_2_6_3_0_235-hdfs-2.7.3.2.6.3.0-235.x86_64 (HDP-2.6)
           Requires: libtirpc-devel
 You could try using --skip-broken to work around the problem
 You could try running: rpm -Va --nofiles --nodigest
2017-11-17 13:04:44,147 - Failed to install package hadoop_2_6_3_0_235-client. Executing '/usr/bin/yum clean metadata'

W celu dokończenia instalacji wystarczy zainstalować brakującą zależność:

Dla Red Hat 7.x

sudo yum install https://www.rpmfind.net/linux/centos/7.6.1810/os/x86_64/Packages/libtirpc-devel-0.2.4-0.15.el7.x86_64.rpm

(Aktualną wersję ścieżki należy sprawdzić na https://rpmfind.net/linux/rpm2html/search.php?query=libtirpc-devel%28x86-64%29&submit=Search+...&system=CentOS&arch=)

Ścieżka do powyższego pliku może się zmieniać (zwiększa się numer wersji), gdy dostaniemy błąd “nie ma pliku” bądź “nie ma nic do zrobienia” należy sprawdzić czy ścieżka jest poprawna.

Zaawansowane aspekty wykorzystania RDD w Apache Spark

Mon, 07 Aug 2017 16:10:38 +0200

W tym poście powiemy sobie o pewnych aspektach działania Sparka w kontekście przetwarzania RDD.

Opóżnione wykonywanie i przechowywanie RDD

Spark podobnie jak wiele innych narzędzia Big Data takich jak Apache Pig, nie wykonuje naszego programu krok po kroku, tylko odkłada sobie polecenia w pamięci i wykonuje dopiero wtedy gdy są potrzebne. Zaletą takiego podejścia jest wykonywanie tylko tych operacji które były niezbędne oraz możliwość ich optymalizacja przez połączenie ich w prostszą operację (np. kilka operacji filtrowania).

Niestety gdy na tym samym zbiorze chcemy wykonać kilka akcji Spark za każdym razem wykona całą listę poleceń potrzebnych do jego uzyskania. Możemy tego uniknąć przez nakazanie Sparkowi zapisania danych zgromadzonych w pośrednich i tymczasowych RDD tak by można było je reużywać. Jest to niezwykle potrzebne w przypadku algorytmów iteracyjnych.

Zapisu możemy dokonać za pomocą funkcji persist(storageLevel) która przyjmuje sposób w jaki dane mają być zapisane w postaci jednej z poniższych wartości:

Poziom	Opis
MEMORY_ONLY	Domyślny poziom, zapisuje RDD tylko w pamięci RAM jako obiekty maszyny wirtualnej Java (JVM). Jeśli RDD nie zmieści się do pamięci, pewne jego fragmenty (partycje) będą wyliczone w locie kiedy będą potrzebne.
MEMORY_AND_DISK	Przechowuje RDD w pamięci RAM jako obiekty JVM, jednakże jeśli zabraknie pamięci pozostałe fragmenty (partycje) są zapisywane na dysku i stamtąd wczytywane w razie potrzeby
MEMORY_ONLY_SER	Zapisuje dane RDD w pamięci RAM ale w postaci zserializowanych obiektów przez co zajmuje mniej miejsca ale zużywa więcej mocy procesora na proces serializacji i deserializacji (dostępny tylko dla języka Java i Scala)
MEMORY_AND_DISK_SER	Dane trzymane są analogicznie jak w MEMORY_ONLY_SER z tym wyjątkiem, że gdy zabraknie pamięci RAM pozostałe partycje RDD są zapisywane na dysku jako zserializowane obiekty (dostępny tylko dla języka Java i Scala)
DISK_ONLY	Zapisuje całe RDD tylko na dysku, dużo wolniejszy zapis i odczyt ale nie zajmuje pamięci RAM
MEMORY_ONLY_2, MEMORY_AND_DISK_2, etc.	Analogicznie do innch poziomów, jednak każda partycja zapisywana jest na dwóch węzłach klastra (replikacja)
OFF_HEAP (eksperymentalna)	Podobnie do MEMORY_ONLY_SER z tym, że używa pamięci off-heap maszyny wirtualnej (jest to część pamięci maszyny wirtualnej która nie jest zarządzana przez Garbage Collector co zwiększa jej wydajność)

UWAGA W przypadku języka Python dostępne są jedynie poziomy: MEMORY_ONLY, MEMORY_ONLY_2, MEMORY_AND_DISK, MEMORY_AND_DISK_2, DISK_ONLY, and DISK_ONLY_2 zaś wszystkie obiekty są zawsze serializowane za pomocą biblioteki Pickle

Gdy wywołamy funkcję persist bez parametrów zostanie użyty domyślny poziom zapisu, czyli MEMORY_ONLY. Na RDD mamy jeszcze funkcję cache która tak naprawdę po wywołaniu wykorzystuje funkcję persist bez parametrów, co oznacza że powinniśmy ją traktować jedynie jako alias dla metody persist bez parametrów.

Gdy zaczyna brakować pamięci RAM, Spark czyści swój cache zgodnie z algorytmem LRU (least-recently-used), czyli usuwane są dane najdłużej ostatnio nieużywane. Istnieje także możliwość ręcznego zwolnienia pamięci za pomocą metody unpersist.

Przetwarzanie RDD par w Apache Spark

Mon, 07 Aug 2017 16:08:07 +0200

W RDD nie musimy przechowywać pojedynczych obiektów, ale możemy tam przekazywać pary obiektów, czyli tak zwane krotki lub z angielskiego tuple. Na takim RDD mamy dostęp do nowych metod usprawniających nam pracę z krotkami.

TWorzenie RDD par w programie sterownika

Scala:

val lines = Map((1,"Ala ma kota"), (2,"Witaj świecie"), (3,"Dwadzieścia tysięcy mil podmorskiej żeglugi"))
val rddPair = sc.parallelize(lines.toSeq)
rddPair.first

Python:

lines = [(1,"Ala ma kota"), (2,"Witaj świecie"), (3,"Dwadzieścia tysięcy mil podmorskiej żeglugi")]
rddPair = sc.parallelize(lines)
rddPair.first()

Transformacje na RDD par

Mapowanie wartości

Podobnie jak dla RDD z pojedynczym oboektem, RDD par udostępnia metodę map pozwalającą zmapować jedno RDD w drugie. Możemy także tej metody z powodzeniem użyć do stworzenia RDD par z zwykłego RDD jak w poniższym przykładzie gdzie mapujemy linie tekstu na krotki zawierające linię i jej długość:

Scala:

val lines = sc.textFile("README.md")
val pairs = lines.map(line => (line, line.split(" ").size))
pairs.take(10).foreach(println)

Python:

lines = sc.textFile("README.md")
pairs = lines.map(lambda line : (line, len(line.split(" "))))
pairs.take(10)

W przypadku RDD par możemy także skorzystać z metody map mapując całą krotkę na inny obiekt lub inną krotkę, ale możemy także skorzystać z funkcji mapValues oraz flatMapValues które to mapują nam same wartości z naszej krotki bez zmiany klucza, oraz w drugim przypadku dokonują także “spłaszczenia” listy tablic na jedną listę wszystkich obiektów, w tym przypadku RDD.

Scala:

val values = List(("Ala",3), ("Tomek", 4), ("Kasia", 5), ("Ala",5), ("Tomek", 3), ("Kasia", 4))
val valueRdd = sc.parallelize(values)
val countRdd = valueRdd.mapValues( v => (v, 1))
countRdd.take(10).foreach(println)

Python:

values = [("Ala",3), ("Tomek", 4), ("Kasia", 5), ("Ala",5), ("Tomek", 3), ("Kasia", 4)]
valueRdd = sc.parallelize(values)
countRdd = valueRdd.mapValues(lambda v : (v, 1))
countRdd.collect()

Redukcja wartości

Oprócz mapowania drugą bardzo popularną operacją jest agregacja której możemy dokonać za pomocą funkcji reduceByKey, combineByKey oraz groupByKey.

Funkcja groupByKey umożliwia nam zgrupowaniu wszystkich wartości występujących pod wspólnym kluczem i zwraca nowe RDD.

Python:

values = [("Ala",3), ("Tomek", 4), ("Kasia", 5), ("Ala",5), ("Tomek", 3), ("Kasia", 4)]
valueRdd = sc.parallelize(values)
group = valueRdd.groupByKey()
group.mapValues(list).collect()

Funkcja reduceByKey pozwala dodatkowo wskazać funkcję która zredukuje zgrupowane wartości do pojedynczego elementu:

Scala:

val values = List(("Ala",3), ("Tomek", 4), ("Kasia", 5), ("Ala",5), ("Tomek", 3), ("Kasia", 4))
val valueRdd = sc.parallelize(values)
val avgRdd = valueRdd.mapValues( v => (v, 1)).
    reduceByKey( (x,y) => (x._1 + y._1, x._2 + y._2) ).
    mapValues( x => (x._1.toDouble / x._2.toDouble) )
avgRdd.take(10).foreach(println)

Python:

values = [("Ala",3), ("Tomek", 4), ("Kasia", 5), ("Ala",5), ("Tomek", 3), ("Kasia", 4)]
valueRdd = sc.parallelize(values)
avgRdd = valueRdd.mapValues(lambda v : (v, 1)).reduceByKey(lambda x,y: (x[0] + y[0], x[1] + y[1]) ).mapValues(lambda x: ( float(x[0]) / float(x[1]) ) )
avgRdd.collect()

MapReduce w RDD

Scala:

val lines = sc.textFile("README.md")
val wordsRdd = lines.flatMap(line => line.split(" "))
val wordCount = wordsRdd.map(x => (x,1)).reduceByKey( (x,y) => x + y)
wordCount.sortByKey().take(10).foreach(println)

Python:

lines = sc.textFile("README.md")
wordsRdd = lines.flatMap(lambda line : line.split(" "))
wordCount = wordsRdd.map(lambda w: (w,1) ).reduceByKey(lambda x, y: x + y )
wordCount.sortByKey().take(10)

lub w znacznie prostszej wersji :)

Scala:

val lines = sc.textFile("README.md")
val wordsRdd = lines.flatMap(line => line.split(" "))
val wordCount = wordsRdd.countByValue()

Python:

lines = sc.textFile("README.md")
wordsRdd = lines.flatMap(lambda line : line.split(" "))
wordCount = wordsRdd.countByValue()
print(wordCount)

Sortowanie po kluczu

Python:

values = [("Ala",3), ("Tomek", 4), ("Kasia", 5), ("Ala",5), ("Tomek", 3), ("Kasia", 4)]
valueRdd = sc.parallelize(values)
sort = valueRdd.sortByKey()
sort.collect()

Zliczanie po kluczu

Python:

values = [("Ala",3), ("Tomek", 4), ("Kasia", 5), ("Ala",5), ("Tomek", 3), ("Kasia", 4)]
valueRdd = sc.parallelize(values)
count = valueRdd.countByKey()
print(count)

Resilient Distributed Dataset w Apache Spark

Thu, 03 Aug 2017 02:00:34 +0200

Wprowadzenie

RDD (Resilient Distributed Datasets) są podstawowym typem danych wykorzystywanym przez Spark aktualnie będącymi częścią tak zwanego Spark Core czyli bazowego modułu Apache Spark.

Na RDD będziemy wykonywać różne metody które dzielimy na transformacje i akcje. Transformacje przekształcają nam RDD w inne RDD, zaś akcje generują z RDD wynik który może być zwrócony do sterownika bądź zapisany w HDFS’ie lub innym obsługiwanym źródle danych.

Tworzenie RDD

W realnych zastosowaniach RDD tworzy się poprzez wczytanie danych z rozproszonych zasobów sieciowych takich jak na przykład HDFS, Cassandra, MongoDB, Amazon S3 i wielu innych. Mając doczynienia z dużo mniejszymi zbiorami, możemy je zaczytać w programie sterownika i przekształcić programowo w rozproszony zbiór RDD. Pomoże nam w tym funkcja parallelize na obiekcie SparkContext (domyślnie dostępny w Shell dla języka Scala i Python). Poniżej przykłady utworzenia takiego zbioru RDD z utworzonej kolekcji w programie sterownika.

Scala:

val lines = sc.parallelize(List("pizza", "hamburger", "lasagne"))

Python:

lines = sc.parallelize(["pizza", "hamburger", "lasagne"])

Do wczytania pliku tekstowego możemy skorzystać z funkcji textFile:

Scala:

val lines = sc.textFile("README.md")

Python:

lines = sc.textFile("README.md")

Transformacje

Mapowanie wartości

Jedną z najpopularnieszych tranformacji jest map pozwalająca na zmianę obiektów jednego RDD na zupełnie inne obiekty w wynikowym RDD. Typ obiektu wejściowego i wynikowego mogą się różnić, np. liczby możemy zmienić na stałe napisowe.

Poniżej przykład mapowania RDD zawierającego liczby na nowe RDD z ich kwadratami.

Scala:

val nums = sc.parallelize(List(1,2,3,4,5))
val squared = nums.map(x => x * x)
val result = squared.collect()
println(result.mkString("\n"))

Python:

nums = sc.parallelize([1,2,3,4,5])
squared = nums.map(lambda x: x * x)
results = squared.collect()
for result in results:
    print result

UWAGA Do wyświetlenia wynikowego RDD użyliśmy funkcji collect która zwróciła tablicę wszystkich elementów w RDD. Przy bardzo dużych RDD ściągnięcie wszystkich wartości do programu sterownika może wygenerować błąd braku wystarczającej ilości pamięci RAM.

Jeśli chcemy by nowe RDD miało więcej obiektów, możemy zwrócić RDD zawierające kolekcje (jeden obiekt wejściowy mapujemy w oddzielną kolekcję) lub użyć metody flatMap zwracającą nowe RDD mające wszystkie nasze nowe obiekty.

Scala:

val lines = sc.parallelize(List("Ala ma kota", "Witaj świecie", "Dwadzieścia tysięcy mil podmorskiej żeglugi"))
val words = lines.flatMap(line => line.split(" "))
val result = words.collect()
println(result.mkString("\n"))

Python:

lines = sc.parallelize(["Ala ma kota", "Witaj świecie", "Dwadzieścia tysięcy mil podmorskiej żeglugi"])
words = lines.flatMap(lambda line: line.split(" "))
results = words.collect()
for result in results:
    print result

Filtrowanie wartośći

Drugą bardzo popularną transformacją jest funkcja filter zwracająca nowe RDD z elementami które spełniły wskazany warunek.

Scala:

val lines = sc.textFile("README.md")
val sparkLines = lines.filter(line => line.contains("Spark"))
sparkLines.count()
sparkLines.first()

lines = sc.textFile("README.md")
sparkLines = lines.filter(lambda line: "Spark" in line)
sparkLines.count()
sparkLines.first()

Pomijanie duplikatów

Jeśli chcemy pominąć duplikaty w naszym rozproszonym RDD możemy skorzystać z funkcji distinct.

Scala:

val nums = sc.parallelize(List(1,2,2,3,4,4,5))
val distinct = nums.distinct()
println(distinct.collect().mkString(", "))

Python:

nums = sc.parallelize([1,2,2,3,4,4,5])
distinct = nums.distinct()
print(distinct.collect())

Próbkowanie

Czasami chcemy przetestować nasz algorytm na mniejszej, czy nawet znacznie mniejszej próbce danych. Idealnie nadaje się do tego funkcja sample która pozwala zwrócić nam tylko część naszego RDD.

Scala:

val nums = sc.parallelize(List(1,2,3,4,5))
val sample = nums.sample(false, 0.5)
println(sample.collect().mkString(", "))

Python:

nums = sc.parallelize([1,2,3,4,5])
sample = nums.sample(False, 0.5)
print(sample.collect())

Trzeba pamiętać, że algorytm jest niederteministyczny, co oznacza, że każde wywołanie programu zwraca nam zupełnie inny wynik.

Operacje na wielu zbiorach

Transformacje nie muszą pracować na jednym RDD ale mogą także operować na wielu zbiorach. Podstawowymi transformacjami działającymi na wielu RDD są:

union - łączenie dwóch RDD
intersection - zwraca część wspólną obydwu RDD (bez duplikatów)
subtract - różnica dwóch zbiorów
cartesian - iloczyn kartezjański, zwraca połączenie każdego elementu pierwszego zbioru z każdym elementem drugiego zbioru

Scala:

val rdd1 = sc.parallelize(List(1,2,3,4,5))
val rdd2 = sc.parallelize(List(4,5,6,7))

val union = rdd1.union(rdd2)
println(union.collect().mkString(", "))

val intersection = rdd1.intersection(rdd2)
println(intersection.collect().mkString(", "))

val subtract = rdd1.subtract(rdd2)
println(subtract.collect().mkString(", "))

val cartesian = rdd1.cartesian(rdd2)
println(cartesian.collect().mkString(", "))

Python:

rdd1 = sc.parallelize([1,2,3,4,5])
rdd2 = sc.parallelize([4,5,6,7])

union = rdd1.union(rdd2)
print(union.collect())

intersection = rdd1.intersection(rdd2)
print(intersection.collect())

subtract = rdd1.subtract(rdd2)
print(subtract.collect())

cartesian = rdd1.cartesian(rdd2)
print(cartesian.collect())

Trzeba jednak pamiętać, że w projektach Big Data takie operacje na dużych zbiorach bywają niezwykle kosztowne obliczeniowo a czasami nawet nie możliwe do przeprowadzenia, np. iloczyn kartezjański dwóch bardzo licznych zbiorów może wygenerować tak duży zbiór wynikowy, którego nie będziemy w stanie zapisać ani w pamięci RAM ani także na naszym dysku. Dodatkowo operacje na zbiorach rozproszonych często mogą spowodować bardzo dużo połączeń i przesunięc danych z jednego serwera na drugi, co także znacząco spowolni nasze obliczenia (nie bazujemy tutaj na tak zwanej lokalności danych).

Akcje

Redukcja RDD

Jedną z najpopularniejszych akcji używanych w Apache Spark jest reduce pozwalająca na zredukowanie całego RDD do pojedynczego obiektu tego samego typu co elementy RDD.

Scala:

val nums = sc.parallelize(List(1,2,3,4,5))
val sum = nums.reduce( (x, y) => x + y)
println(sum)

Python:

nums = sc.parallelize([1,2,3,4,5])
sum = nums.reduce(lambda x, y: x + y)
print(sum)

Podobnie działa funkcja fold umożliwiająca redukcję z wartością startową (wartość ta nie powinna wpływać na wynik, np. pusta lista lub wartość zero dla sumy).

Scala:

val nums = sc.parallelize(List(1,2,3,4,5))
val sum = nums.fold(0)((x, y) => x + y)
println(sum)

Python:

nums = sc.parallelize([1,2,3,4,5])
sum = nums.fold(0, lambda x, y: x + y)
print(sum)

Jeśli dodatkowo chcemy zmienić typ zwracanej wartości, musimy skorzystać z jeszcze innej funkcji o nazwie aggregate która także przyjmuje wartość startową. Do aggregate musimy przekazać dwie funkcje, pierwsza służy do redukcji w ramach partycji (danych zgromadzonych fizycznie razem na jednej maszynie) a następnie drugiej funkcji która łączy ze sobą wyniki z poprzedniego kroku.

W poniższym przykładzie zwrócimy krotkę (tuple) zawierającą zarówno sumę jak i liczbę obiektów, co wykorzystamy do wyliczenia średniej.

Scala:

val nums = sc.parallelize(List(1,2,3,4,5,6))
val sumCount = nums.aggregate((0, 0))(
    (acc, value) => (acc._1 + value, acc._2 + 1),
    (acc1, acc2) => (acc1._1 + acc2._1, acc1._2 + acc2._2)
)
println(sumCount)
val avg = sumCount._1.toDouble / sumCount._2.toDouble
println(avg)

Python:

nums = sc.parallelize([1,2,3,4,5,6])
sumCount = nums.aggregate((0,0),
    (lambda acc, value: (acc[0] + value, acc[1] + 1) ),
    (lambda acc1, acc2: (acc1[0] + acc2[0], acc1[1] + acc2[1]) )
)
print(sumCount)
avg = float(sumCount[0]) / float(sumCount[1])
print(avg)

Pobieranie danych do programu sterownika

Jeśli po przetworzeniu nasze RDD jest na tyle małe, że może nam się zmieścić w pamięci RAM maszyny na której uruchomiliśmy nasz program sterownik, możemy skorzystać z możliwości ściągnięcia ich na tą maszynę i tam zapisanie lub dalsze przetworzenie.

Najprostrzym sposobem na to jest używana we wcześniejszych przykładach funkcja collect zwracająca RDD jako zwykła kolekcja obiektów.

W sytuacji gdy nie potrzebujemy pobierać całego RDD na lokalną maszynę możemy użyć funkcji take(n) zwracająca n dowolnych elementów, top(n) zwracająca najwyższe elementy, takeOrdered analogiczna do top ale umożliwiająca przekazanie własnej funkcji porównującej oraz takeSample(withReplacement, n, seed) zwracająca n elementów w losowy sposób.

Jeszcze inną przydatną funkcją jest first zwracająca pierwszy element RDD.

Zliczanie ilości

Jeśli chcemy sprawdzić ile elementów zawiera nasz RDD możemy skorzystać z funkcji count oraz countByValue zwracająca ilość unikalnych elementów w postaci mapy element -> liczność.

Python:

nums = sc.parallelize([1,1,3,3,5])
count = nums.count()
print(count)

countByValue = nums.countByValue()
print(countByValue)

Wykonywanie operacji na każdym elemencie

Jeśli zajdzie nam potrzeba wykonania jakiejś operacji na każdym elemencie w sposób rozproszony bez konieczności zwracania jej wyniku, możemy skorzystać z funkcji foreach.

Python:

nums = sc.parallelize([1,1,3,3,5])
def f(x): print(x)

nums.foreach(f)

Legenda

Strona projektu http://spark.apache.org
Dokumentacja https://spark.apache.org/docs/latest/
API dla języka Scala https://spark.apache.org/docs/latest/api/scala/index.html
API dla języka Java https://spark.apache.org/docs/latest/api/java/index.html
API dla języka Python https://spark.apache.org/docs/latest/api/python/index.html
Biblioteka Pickle dla Pythona https://docs.python.org/2/library/pickle.html

Podstawy programowania Apache Spark

Sun, 30 Jul 2017 14:49:14 +0200

Programowanie Apache Spark

Apache Spark został napisany w języku Scala, przez co domyślnym językiem programowania jak i tym które oferuje najwięcej możliwości jest właśnie Scala. Dzięki wyjątkowo dobrej kompatybilności Scali z językiem Java, drugim językiem programowania jaki jest dostępny dla tej platformy jest oczywiście język Java oferujący od wersji 8 wiele funkcjonalności zbliżonych do języka Scala (dosłownie rzecz biorąc, twórcy języka Java w wersji 8 wzorowali się między innymi na języku Scala wprowadzając nowe funkcjonalności). Z racji dużej popularności języka Python wśród analityków i inżynierów Big Data, twórcy także dodali wsparcie dla tego języka. Osoby nie mający doświadczenia z programowaniem w powyższych językach ale znający pakiet R mogą także skorzystać z API stworzonego dla tego języka (o tym w innych postach). Ostatnim językiem który mogą wykorzystać użytkownicy Apache Spark jest obecnie najpopularniejszy język świata jakim jest język SQL. Można tutaj skorzystać zarówno z modułu zwanego Spark SQL ale także użytkownicy Apache Hive mogą skonfigurować go do wykorzystania Apache Spark jako silnika przetwarzającego dane (obok Apache Hadoop MapReduce czy Apache Tez).

W tym poście skupimy się na podstawach programowania w języku Scala, Java i Python.

Podstawowe operacje Apache Spark czyli zliczanie słów

Jednymi z podstawowych funkcji Apache Spark są funkcje map i reduce, dobrze znane programistom języków funkcyjnych czy użytkownikom Apache Hadoop oraz innych narzędzi jak MongoDB, Cassandra implementujących paradygmat MapReduce.

Funkcja map służy do transformacji jednego bytu w coś innego, np możemy zmienić linijki w liczbę oznaczającą liczbę słów w tej linii:

val textFile = spark.read.textFile("README.md")
val lineSizeDataset = textFile.map(line => line.split(" ").size)
lineSizeDataset.show(10)

w wyniku czego otrzymamy w konsoli następujący rezultat:

scala> val textFile = spark.read.textFile("README.md")
textFile: org.apache.spark.sql.Dataset[String] = [value: string]

scala> val lineSizeDataset = textFile.map(line => line.split(" ").size)
lineSizeDataset: org.apache.spark.sql.Dataset[Int] = [value: int]

scala> lineSizeDataset.show(10)
+-----+
|value|
+-----+
|    3|
|    1|
|   14|
|   13|
|   11|
|   12|
|    8|
|    6|
|    1|
|    1|
+-----+
only showing top 10 rows

Jak widać funkcja map utworzyła nam nowy Dataset zawierający tyle samo elementów, jednak jako wartości są ilości słów w linii. Dodatkowo na koniec dodałem funkcję show która wyświetla przekazaną ilość parametrów w konsoli z kolekcji typu Dataset.

Funkcja reduce służy do “redukcji” naszego zbioru, czyli jego “uproszczeniu”. W tym przypadku chcemy zsumować liczbę słów w każdej linijce tekstu by otrzymać łączną liczbę słów w całym tekście.

val textFile = spark.read.textFile("README.md")
val lineSizeDataset = textFile.map(line => line.split(" ").size)
val textFileWordCount = lineSizeDataset.reduce((a, b) => a + b)

Po uruchomieniu programu otrzymaliśmy wynik w postaci:

scala> val textFile = spark.read.textFile("README.md")
textFile: org.apache.spark.sql.Dataset[String] = [value: string]

scala> val lineSizeDataset = textFile.map(line => line.split(" ").size)
lineSizeDataset: org.apache.spark.sql.Dataset[Int] = [value: int]

scala> val textFileWordCount = lineSizeDataset.reduce((a, b) => a + b)
textFileWordCount: Int = 566

czyli cały tekst ma 566 słów.

Ten sam przykład w języku Python:

textFile = spark.read.text("README.md")
from pyspark.sql.functions import *

lineSizeDataset = textFile.select(size(split(textFile.value, "\s")).name("numWords"))
lineSizeDataset.show(10)

textFileWordCount = lineSizeDataset.agg(sum(col("numWords")).name("result")).collect()[0][0]
textFileWordCount

wynik:

>>> textFile = spark.read.text("README.md")
>>> from pyspark.sql.functions import *
>>> 
>>> lineSizeDataset = textFile.select(size(split(textFile.value, "\s")).name("numWords"))
>>> lineSizeDataset.show(10)
+--------+
|numWords|
+--------+
|       3|
|       1|
|      14|
|      13|
|      11|
|      12|
|       8|
|       6|
|       1|
|       1|
+--------+
only showing top 10 rows

>>> 
>>> textFileWordCount = lineSizeDataset.agg(sum(col("numWords")).name("result")).collect()[0][0]
>>> textFileWordCount

API dla DataFrame jest trochę inne niż w języku Scala, tutaj nie użyliśmy funkcji map tylko select, zaś zamiast reduce użyliśmy funkcji agg. Dodatkowo skorzystaliśmy z wbudowanych w język Python funkcji.

Apache Spark i MapReduce

Osoby które znają paradygmat MapReduce i korzystali z projektu Apache Hadoop, wiedzą, że swoistym “Witaj Świecie” dla aplikacji typu MapReduce jest przypadek zliczania ilości wystąpień każdego ze słów a nie wszystkich razem. Taki przypadek także bardzo łatwo uzyskać za pomocą Apache Spark korzystając z funkcji flatMap oraz groupByKey:

val textFile = spark.read.textFile("README.md")
val wordCounts = textFile.flatMap(line => line.split(" ")).groupByKey(identity).count()
wordCounts.sort($"count(1)".desc).show(10)

w wyniku otrzymujemy:

scala> val textFile = spark.read.textFile("README.md")
textFile: org.apache.spark.sql.Dataset[String] = [value: string]

scala> val wordCounts = textFile.flatMap(line => line.split(" ")).groupByKey(identity).count()
wordCounts: org.apache.spark.sql.Dataset[(String, Long)] = [value: string, count(1): bigint]

scala> wordCounts.sort($"count(1)".desc).show(10)
+-----+--------+
|value|count(1)|
+-----+--------+
|     |      71|
|  the|      24|
|   to|      17|
|Spark|      16|
|  for|      12|
|   ##|       9|
|  and|       9|
|    a|       8|
|   on|       7|
|  run|       7|
+-----+--------+
only showing top 10 rows

Pierwszą różnicą w stosunku do poprzedniego przypadku jest użycie flatMap zamiast map. Robimy to dlatego że w pierwszym przypadku mapowaliśmy linie tekstu na ilość słów w tej linii, czyli dla każdego elementu wejściowego zbioru produkowaliśmy dokładnie jeden element wynikowy. W drugim przypadku dla jednej linijki tekstu produkujemy listę słów, czyli ostatecznie mamy Dataset złożony z tablicy obiektów co można zauważyć na poniższym fragmencie kodu:

val textFile = spark.read.textFile("README.md")
val wordsDataset = textFile.map(line => line.split(" "))
wordsDataset.show(10)

w wyniku otrzymujemy:

scala> val textFile = spark.read.textFile("README.md")
textFile: org.apache.spark.sql.Dataset[String] = [value: string]

scala> val wordsDataset = textFile.map(line => line.split(" "))
wordsDataset: org.apache.spark.sql.Dataset[Array[String]] = [value: array<string>]

scala> wordsDataset.show(10)
+--------------------+
|               value|
+--------------------+
|  [#, Apache, Spark]|
|                  []|
|[Spark, is, a, fa...|
|[high-level, APIs...|
|[supports, genera...|
|[rich, set, of, h...|
|[MLlib, for, mach...|
|[and, Spark, Stre...|
|                  []|
|[<http://spark.ap...|
+--------------------+
only showing top 10 rows

Z racji tego że chcemy ostatecznie mieć Dataset zawierający wszystkie słowa a nie tablice słów, musimy go niejako “spłaszczyć”, czyli z angielskiego “to flat”.

Podobnie jest w przypadku funkcji reduce i groupByKey. Pierwsza funkcja pozwala nam zredukować Dataset do pojedynczej wartości, zaś druga użyta w tym przypadku funkcja robi dokładnie to co silnik MapReduce, czyli grupuje nam wszystkie identyczne elementy z wejściowego Dataset w jeden podzbiór, gdzie dla każdego wykonujemy funkcję count zwracającą nam jego liczność.

W przypadku języka Python powyższy algorytm MapReduce mógłby wyglądać tak:

textFile = spark.read.text("README.md")
from pyspark.sql.functions import *
wordCounts = textFile.select(explode(split(textFile.value, "\s")).name("word")).groupBy("word").count()
wordCounts.sort("count",ascending=False).show(10)

wynik:

>>> textFile = spark.read.text("README.md")
>>> from pyspark.sql.functions import *
>>> wordCounts = textFile.select(explode(split(textFile.value, "\s")).name("word")).groupBy("word").count()
>>> wordCounts.sort("count",ascending=False).show(10)
+-----+-----+
| word|count|
+-----+-----+
|     |   71|
|  the|   24|
|   to|   17|
|Spark|   16|
|  for|   12|
|   ##|    9|
|  and|    9|
|    a|    8|
|   on|    7|
|  run|    7|
+-----+-----+
only showing top 10 rows

Jak widać, nasz rezultat jest identyczny jak w przypadku języka Scala. Tutaj także skorzystaliśmy z funkcji select w kombinacji z explode zamiast z flatMap oraz funkcji groupBy zamiast groupByKey.

Legenda

Strona projektu http://spark.apache.org
Dokumentacja https://spark.apache.org/docs/latest/
API dla języka Scala https://spark.apache.org/docs/latest/api/scala/index.html
API dla języka Java https://spark.apache.org/docs/latest/api/java/index.html
API dla języka Python https://spark.apache.org/docs/latest/api/python/index.html
Spark SQL https://spark.apache.org/sql/
Hive na Spark’u https://cwiki.apache.org/confluence/display/Hive/Hive+on+Spark%3A+Getting+Started
Hive na Spark’u (JIRA) https://issues.apache.org/jira/browse/HIVE-7292

Szybki start z Apache Spark

Sat, 29 Jul 2017 13:18:41 +0200

Pobranie Apache Spark

Sparka najlepiej pobrać ze strony projektu: http://spark.apache.org/downloads.html. Ja skorzystam z wersji 2.2.0 przystosowanej do pracy z Apache Hadoop w wersji 2.7 lub wyższej. Po ściągnięciu należy wypakować w dowolnym katalogu na dysku.

Spark działa na systemach z rodziny Windows oraz Unix (Linux, MacOS, etc.). Ja skorzystam z systemu Linux Mint.

Do działa Sparka będzie wymagana Java 8+, Python 2.7+/3.4+ i R 3.1+ oraz Scala 2.11 (ze względu na kompatybilność musimy użyć dokładnie tej wersji 2.11.x).

Uruchomienie

Po rozpakowaniu ściągniętej paczki, wchodzi do utworzonego katalogu i w konsoli wykonujemy polecenie:

cd spark-2.2.0-bin-hadoop2.7/
./bin/run-example SparkPi 10

Jeśli wszystko poszło tak jak trzeba w wyniku otrzymany stos logów gdzie pod koniec powinniśmy zobaczyć taką wiadomość:

Pi is roughly 3.1416831416831417

Uruchomiliśmy jeden z przykładowych algorytmów zaimplementowanych dla Apache Spark wyliczający liczbę PI.

Gdybyśmy chcieli uruchomić powyższy przykład wykorzystując zamiast języka Scala język Python musimy w konsoli wpisać:

./bin/spark-submit examples/src/main/python/pi.py 10

otrzymując w wyniku:

Pi is roughly 3.144064

Podobnie można postąpić w przypadku języka R:

./bin/spark-submit examples/src/main/r/dataframe.R

(Uwaga, Api dla języka R jest wciąż oznaczone jako eksperymentalne i zawiera tylko podzbiór możliwości Sparka, ale o różnicach w API dla różnych języków w innym poście.)

Uruchomienie w trybie interaktywnym

W poprzednim przykładzie zadanie zostało uruchomienie w sparku za pomocą skryptu spark-submit (https://spark.apache.org/docs/latest/submitting-applications.html), czyli nasze zadanie (w tym przypadku zadanie z przykładów) zostało w całości wysłane do Sparka i przez niego uruchomione.

Istnieje jednak możliwość uruchomienia Sparka lokalnie w trybie interaktywnym, gdzie Spark linijka po linijce będzie wykonywał nasze polecenia. Tryb ten jest tak naprawdę modyfikacją trybu interaktywnego języka Scala.

Aby włączyć tryb interaktywny dla języka Scala należy w konsoli wykonać polecenia:

./bin/spark-shell --master local[2]

dla języka Python:

./bin/pyspark --master local[2]

zaś dla języka R:

./bin/sparkR --master local[2]

(Uwaga, język Java dopiero od wersji 9 udostępnia tryb interaktywny, dlatego nie jest on jeszcze dostępny w Sparku, niemniej język Scala jest kompatybilny z językiem Java, więc z powodzeniem można użyć tego trybu do pracy z językiem Java).

Parametr “master” pozwala nam zdefiniować w ilu wątkach będzie uruchomiony Spark (local[2] oznacza dwa wątki) a także możliwość podłączenia się do uruchomionego wcześniej Sparka (https://spark.apache.org/docs/latest/submitting-applications.html#master-urls).

Panel WWW Spark’a

Po uruchomieniu Spark’a (także w trybie interaktywnym) możemy wejść na jego interfejs graficzny dostępny pod adresem http://localhost:4040.

Idea Sparka

Spark od początku istnienia opiera się na idei Resilient Distributed Dataset (RDD) która została po raz pierwszy przedstawiona w publikacji naukowej Resilient Distributed Datasets: A Fault-Tolerant Abstraction for In-Memory Cluster Computing autorstwa twórcy narzędzia Matei Zaharia w 2012 roku (https://cs.stanford.edu/~matei/papers/2012/nsdi_spark.pdf).

RDD to tak naprawdę niezmienna (brak edycji) rozproszona kolekcja danych, przechowywana przez węzły klastra obliczeniowego. RDD mogą być przetwarzane w sposób rozproszony i wielowątkowy, zaś podstawowymi operacjami na RDD są akcje i transformacje.

Wraz z rozwojem Spark’a oraz wzrostem jego popularności, twórcy chcieli udostępnić narzędzie szerszemu gronu użytkowników poprzez rozszerzenie API. Na wzór “data frames” dostępnych w języku R oraz Python (Pandas) twórcy Apache Spark stworzyli nowy typ zwany DataFrame. Podobnie do RDD, DataFrame to rozproszona kolekcja danych, jednakże dane są zorganizowane w nazwane kolumny, analogicznie jak to ma miejsce w bazach danych czy narzędziach typu Apache Hive. Dodatkowo DataFrame posiadają wiele optymalizacji (Catalyst optimizer) i udogodnień w API (domain-specific language). Także podobnie do RDD wszelkie operacje są buforowane i wykonywane dopiero gdy to niezbędne (lazy), przez co Spark może zastosować wiele optymalizacji.

W wersji 1.6 Apache Spark zostało wprowadzone trzecie API zwane Dataset. W przeciwieństwie do DataFrame, nowe Api jest silnie typowane (type-safe) oraz zorientowane obiektowo (object-oriented programming interface). Dodatkowo posiada jeszcze więcej optymalizacji (Catalyst Optimizer i Tungsten project). Użytkowo API jest bardzo zbliżone do RDD, przez co Dataset stał się optymalnym rozwiązaniem łączącym zalety zarówno DataFrame jak i RDD, przy dużo większej wydajności i mniejszym użyciu pamięci RAM niż RDD.

Wraz z pojawieniem się wersji 2.0 Spark’a, API dla DataFrame i Dataset zostało zunifikowane w pewnym stopniu, dzięki czemu korzystanie z nich stało się znacznie prostsze. Niestety względu na specyfikę języków programowania, nie każde API jest dostępne dla każdego języka, co przedstawia tabela:

Język	Dostępne API
Scala	Dataset[T] & DataFrame (alias, DataFrame = Dataset[Row])
Java	Dataset[T]
Python	DataFrame
R	DataFrame

Jak widać silnie typowany język Java obsługuje Datset, zaś przeciwny jemu Python i R powinien korzystać z DataFrame. W języku Scala możemy korzystać z obydwu API. Trzeba zauważyć, że wraz z unifikacją API typ DataFrame to tak naprawdę alias dla typu Dataset[Row].

Podsumowując, jeśli korzystamy ze Sparka, twórcy zalecają korzystanie z Dataset lub DataFrame ze względu na optymalizacje i wygodniejsze API. Jeśli jednak potrzebujemy API niższego poziomu i możemy pominąć optymalizacje wykorzystane w Dataset lub DataFrame, możemy nadal korzystać z klasycznych RDD.

Pierwsze kroki

Zacznijmy od wczytania jakiegoś pliku z lokalnego dysku:

scala> val textFile = spark.read.textFile("README.md")
textFile: org.apache.spark.sql.Dataset[String] = [value: string]

w wyniku Shell języka Scala informuje nas o stworzeniu wartości (val) typu Dataset (org.apache.spark.sql.Dataset[String]) i nazwie “textFile”.

Na takim obiekcie możemy wykonywać wiele operacji, np:

val textFile = spark.read.textFile("README.md")
textFile.count()
textFile.first()
val linesWithSpark = textFile.filter(line => line.contains("Spark"))
linesWithSpark.count()
linesWithSpark.first()

W powyższym programie po wczytaniu pliku “README.md” (który znajduje się w bieżącej lokalizacji, czyli w rozpakowanym katalogu Apache Spark) zliczyliśmy liczbę wierszy za pomocą funkcji count oraz zwróciliśmy pierwszy element kolekcji, czyli w naszym przypadku pierwszą linijkę. Następnie stworzyliśmy nowy Dataset za pomocą funkcji filter którą wybraliśmy tylko te wiersze które zawierają słowo “Spark”. Z racji że funkcja filter zwraca kolejny Dataset, na nim także można wywołać funkcje takie jak first oraz count

Te same operacje bardzo łatwo możemy wykonać używając języka Python:

textFile = spark.read.text("README.md")
textFile.count()
textFile.first()
linesWithSpark = textFile.filter(textFile.value.contains("Spark"))
linesWithSpark.count()
linesWithSpark.first()

W przypadku języka Python kod wygląda prawie identycznie, z tym wyjątkiem, że w tym przypadku używany jest oczywiście typ DataFrame. Także sam shell nie zwraca informacji o stworzonych obiektach, jak to się dzieje w przypadku shell’a dla języka Scala.

Podsumowanie

Jeśli udało Ci się zainstalować i uruchomić Apache Spark na swoim komputerze, jesteś na dobrej drodze do poznania tego narzędzia. W kolejnych postach przedstawię znacznie więcej informacji Apache Spark, w tym informacje o architekturze, zasadzie działania, instalacji na klastrze i programowaniu.

Legenda

Strona projektu http://spark.apache.org
Strona pobierania http://spark.apache.org/downloads.html
Dokumentacja https://spark.apache.org/docs/latest/
Wysyłanie zadania https://spark.apache.org/docs/latest/submitting-applications.html
Parametry dla trybu interaktywnego https://spark.apache.org/docs/latest/submitting-applications.html#master-urls
API dla języka Scala https://spark.apache.org/docs/latest/api/scala/index.html
API dla języka Java https://spark.apache.org/docs/latest/api/java/index.html
API dla języka Python https://spark.apache.org/docs/latest/api/python/index.html
API dla języka R https://spark.apache.org/docs/latest/api/R/index.html
DataFrame https://databricks.com/blog/2015/02/17/introducing-dataframes-in-spark-for-large-scale-data-science.html
Dataset https://databricks.com/blog/2016/01/04/introducing-apache-spark-datasets.html
RDD vs Dataframe vs Dataset https://databricks.com/blog/2016/07/14/a-tale-of-three-apache-spark-apis-rdds-dataframes-and-datasets.html

Wprowadzenie do Apache Spark

Sat, 29 Jul 2017 13:18:32 +0200

Apache Spark to platforma obliczeniowa stworzona z myślą o przetwarzaniu danych.

Spark powstał jako odpowiedź na ograniczenia paradygmatu MapReduce wykorzystywanym przez projekt Apache Hadoop który z założenia przetwarza dane w trybie wsadowym, to znaczy między innymi, że za każdym razem wczytuje i zapisuje je na dysk (HDFS) przez co jego wydajność w algorytmach iteracyjnych jest dość ograniczona. W Apache Spark została wprowadzona idea Resilient Distributed Dataset czyli zbiorów danych które są przechowywane w pamięci dzięki czemu mogą być wykorzystane przez kolejne algorytmy bądź iteracje bez potrzeby ich ponownego wczytywania z dysku. Oczywiście konsekwencją jest znaczne zużycie pamięci RAM w naszym klastrze i jeśli wielkość przetwarzanych danych znacząco przerasta wielkość pamięci operacyjnej na klastrze, Spark potrafi przechowywać je korzystając z dysków twardych podobnie jak to robi Apache Hadoop MapReduce.

Autorem Apache Spark jest Matei Zaharia będący pracownikiem naukowych uniwersytetu Stanforda (https://www.stanford.edu/). Spark powstał jako element pracy naukowej jego autora, dokładnie studiów doktoranckich, na uniwersytecie Berkeley (http://www.berkeley.edu/), zaś idea RDD została po raz pierwszy przez Niego przedstawiona w publikacji naukowej Resilient Distributed Datasets: A Fault-Tolerant Abstraction for In-Memory Cluster Computing (https://cs.stanford.edu/~matei/papers/2012/nsdi_spark.pdf) w 2012 roku. Matei Zaharia jest także współautorem Apache Mesos oraz brał udział przy tworzeniu niektórych algorytmów w narzędziu Apache Hadoop. Obecnie projekt jest rozwijany pod patronatem fundacji Apache głównie przez założoną przez autora firmę Databricks. Pierwszy raz Spark został wydany 30 maja 2014 roku.

Apache Spark można zainstalować w wersji rozproszonej za pomocą natywnej implementacji (opartej o Akka), narzędzia Apache Mesos oraz Hadoop YARN.

Dane można wczytywać z lokalnego dysku lub rozproszonych systemów składowania danych jak Hadoop Distributed File System (HDFS), MapR File System (MapR-FS), Cassandra, OpenStack Swift, Amazon S3, Kudu i innych, a nawet zaimplementować własny sterownik do obsługi zewnętrznych źródeł danych lub znaleźć gotową implementację w sieci.

Apache Spark został napisany w języku Scala, jednak udostępnia wsparcie (tak zwane API) dla języka Scala, Java, Python oraz R, jednakże API dla języka Scala udostępnia najwięcej możliwości.

Legenda:

Uniwersytet Berkeley http://www.berkeley.edu/
Uniwersytet Stanforda https://www.stanford.edu/
Strona domowa Matei Zaharia http://cs.stanford.edu/~matei/
Publikacja na temat RDD https://cs.stanford.edu/~matei/papers/2012/nsdi_spark.pdf
Strona domowa projektu http://spark.apache.org

Sandbox Big Data

Fri, 07 Jul 2017 00:00:00 +0000

W dzisiejszym poście chciałbym Wam udostępnić maszynę wirtualną z którą można łatwo rozpocząć swoją przygodę z Big Data. Wiele osób uczestniczących w naszych kursach Big Data i Data Science narzeka, że dla początkujących osób często problemem jest zestawienia sobie odpowiedniego środowiska.

By wyjść naprzeciw tym wszystkim osobom przygotowałem specjalną maszynę wirtualną która zawiera:

System CentOS 7.5
Java
Scala
IntelliJ IDEA
Docker
Docker Compose
Git
Maven
Dystrybucja Hortonworks

oraz wiele innych przydatnych narzędzi. W środku wrzucony jest także nasz otwarto źródłowy projekt: https://github.com/sagespl/HADOOP oraz przykładowe dane do pracy.

Praca w środowisku graficznym

Najłatwiej zacząć pracę z samą maszyną w środowisku graficznym. W tym celu należy ją jedynie uruchomić i zalogować się jako:

user: sages
pass: hadoop

Do dyspozycji mamy GNOME 3, bardzo ergonomiczny manager do codziennej pracy.

Praca z SSH

Do maszyny można też połączyć się

ssh root@localhost -p 2222

Dzięki SSH można też tunelować sobie niektóre porty (inaczej mówiąc mapować porty z maszyny wirtualnej na nasz komputer)

ssh root@localhost -L 8020:localhost:8020 -L 50070:localhost:50070 -p 2222
ssh root@localhost -L 8020:localhost:8020 -L 50070:localhost:50070 -L 2181:localhost:2181 -L 16000:localhost:16000 -L 16020:localhost:16020 -p 2222
ssh root@localhost -L 9092:localhost:9092 -L 9093:localhost:9093 -L 9094:localhost:9094 -p 2222

Jeśli nie chcemy wpisywać za każdym razem ciągu znaków jak wyżej, możemy sobie całość zdefiniować w pliku ~/.ssh/config

Host bigdatasandbox
    Hostname localhost
    Port 2222
    User root
    LocalForward 8020 localhost:8020
    LocalForward 50070 localhost:50070
    LocalForward 9092 localhost:9092
    LocalForward 6667 localhost:6667

Możemy po ssh także zamontować sobie dysk z maszyny w naszym własnym (można też użyć odpowiednich opcji z VirtualBoxa)

mkdir /tmp/sages
sshfs sages@localhost:/home/sages /tmp/sages/ -p 2222 -o cache_timeout=80 -f -o allow_other -o no_remote_lock

Mapowanie portów

W maszynie jest zainstalowana dystrybucja Big Data firmy Hortonworks tak zwana Hortonworks Data Platform która pracuje na następujących portach:

Ambari jest dostępne na porcie 8080:

http://sandbox.hortonworks.com:8080

W maszynie wirtualnej wystawione są następujące porty:

VBoxManage modifyvm "Big Data Sandbox" --natpf1 delete "SSH"
VBoxManage modifyvm "Big Data Sandbox" --natpf1 delete "Ambari"
VBoxManage modifyvm "Big Data Sandbox" --natpf1 delete "NameNodeHttp"
VBoxManage modifyvm "Big Data Sandbox" --natpf1 delete "NameNodeHttps"
VBoxManage modifyvm "Big Data Sandbox" --natpf1 delete "NameNodeMetadata"
VBoxManage modifyvm "Big Data Sandbox" --natpf1 delete "DataNodeHttp"
VBoxManage modifyvm "Big Data Sandbox" --natpf1 delete "DataNodeHttps"
VBoxManage modifyvm "Big Data Sandbox" --natpf1 delete "DataNodeData"
VBoxManage modifyvm "Big Data Sandbox" --natpf1 delete "DataNodeDatas"
VBoxManage modifyvm "Big Data Sandbox" --natpf1 delete "DataNodeMetadata"
VBoxManage modifyvm "Big Data Sandbox" --natpf1 delete "SecondaryNameNodeHttp"
VBoxManage modifyvm "Big Data Sandbox" --natpf1 delete "ResourceManagerUI"
VBoxManage modifyvm "Big Data Sandbox" --natpf1 delete "JobHistoryUI"
VBoxManage modifyvm "Big Data Sandbox" --natpf1 delete "Zookeeper"
VBoxManage modifyvm "Big Data Sandbox" --natpf1 delete "HMaster"
VBoxManage modifyvm "Big Data Sandbox" --natpf1 delete "HMasterInfoWebUI"
VBoxManage modifyvm "Big Data Sandbox" --natpf1 delete "RegionServer"
VBoxManage modifyvm "Big Data Sandbox" --natpf1 delete "RegionServerInfo"
VBoxManage modifyvm "Big Data Sandbox" --natpf1 delete "SparkHistoryUI"
VBoxManage modifyvm "Big Data Sandbox" --natpf1 delete "Spark2HistoryUI"
VBoxManage modifyvm "Big Data Sandbox" --natpf1 delete "Oozie"
VBoxManage modifyvm "Big Data Sandbox" --natpf1 delete "Kafka"
VBoxManage modifyvm "Big Data Sandbox" --natpf1 delete "KafkaAmbari"

VBoxManage showvminfo "Big Data Sandbox" | grep Rule

VBoxManage modifyvm "Big Data Sandbox" --natpf1 "SSH,tcp,127.0.0.1,2222,,22"
VBoxManage modifyvm "Big Data Sandbox" --natpf1 "Ambari,tcp,127.0.0.1,8080,,8080"
#VBoxManage modifyvm "Big Data Sandbox" --natpf1 "NameNodeHttp,tcp,127.0.0.1,50070,,50070"
VBoxManage modifyvm "Big Data Sandbox" --natpf1 "NameNodeHttps,tcp,127.0.0.1,50470,,50470"
#VBoxManage modifyvm "Big Data Sandbox" --natpf1 "NameNodeMetadata,tcp,127.0.0.1,8020,,8020"
VBoxManage modifyvm "Big Data Sandbox" --natpf1 "DataNodeHttp,tcp,127.0.0.1,50075,,50075"
VBoxManage modifyvm "Big Data Sandbox" --natpf1 "DataNodeHttps,tcp,127.0.0.1,50475,,50475"
VBoxManage modifyvm "Big Data Sandbox" --natpf1 "DataNodeData,tcp,127.0.0.1,50010,,50010"
VBoxManage modifyvm "Big Data Sandbox" --natpf1 "DataNodeDatas,tcp,127.0.0.1,1019,,1019"
VBoxManage modifyvm "Big Data Sandbox" --natpf1 "DataNodeMetadata,tcp,127.0.0.1,50020,,50020"
VBoxManage modifyvm "Big Data Sandbox" --natpf1 "SecondaryNameNodeHttp,tcp,127.0.0.1,50090,,50090"
VBoxManage modifyvm "Big Data Sandbox" --natpf1 "ResourceManagerUI,tcp,127.0.0.1,8088,,8088"
VBoxManage modifyvm "Big Data Sandbox" --natpf1 "JobHistoryUI,tcp,127.0.0.1,19888,,19888"
VBoxManage modifyvm "Big Data Sandbox" --natpf1 "Zookeeper,tcp,127.0.0.1,2181,,2181"
VBoxManage modifyvm "Big Data Sandbox" --natpf1 "HMaster,tcp,127.0.0.1,16000,,16000"
VBoxManage modifyvm "Big Data Sandbox" --natpf1 "HMasterInfoWebUI,tcp,127.0.0.1,16010,,16010"
VBoxManage modifyvm "Big Data Sandbox" --natpf1 "RegionServer,tcp,127.0.0.1,16020,,16020"
VBoxManage modifyvm "Big Data Sandbox" --natpf1 "RegionServerInfo,tcp,127.0.0.1,16030,,16030"
VBoxManage modifyvm "Big Data Sandbox" --natpf1 "SparkHistoryUI,tcp,127.0.0.1,18080,,18080"
VBoxManage modifyvm "Big Data Sandbox" --natpf1 "Spark2HistoryUI,tcp,127.0.0.1,18081,,18081"
VBoxManage modifyvm "Big Data Sandbox" --natpf1 "Oozie,tcp,127.0.0.1,11000,,11000"
#VBoxManage modifyvm "Big Data Sandbox" --natpf1 "Kafka,tcp,127.0.0.1,9092,,9092"
#VBoxManage modifyvm "Big Data Sandbox" --natpf1 "KafkaAmbari,tcp,127.0.0.1,6667,,6667"

VBoxManage showvminfo "Big Data Sandbox" | grep Rule

Uruchomienie maszyny

Możemy to zrobić z GUI programu VirtualBox lub z konsoli:

VBoxManage startvm "Big Data Sandbox"
VBoxManage startvm "Big Data Sandbox" --type headless

Instalacja dystrybucji Hortonworks Data Platform za pomocą Apache Ambari

Mon, 03 Jul 2017 00:00:00 +0000

Instrukcja instalacji dystrybucji Hortonworks Data Platform HDP-2.6 na maszynach z systemem Red Hat 7 lub CentOS 7.

Do instalacji zostanie użyte:

HDP-2.6.3.0
Apache Ambari w wersji 2.5.1.0.
CentOS 7.5.1804 (Minimal ISO)

W przypadku systemów produkcyjnych jedyną zalecaną opcją jest instalacja w klastrze kilku maszyn. Jedną maszynę możemy wykorzystywać do celów testowych i developerskich.

Przygotowanie maszyn

Taką instalację możemy przeprowadzić w dowolnym środowisku, np. z użyciem VirtualBoxa lub chmury AWS

Klaster ssh

Jeśli chcemy wykonywać wybrane polecenia jednocześnie na wszystkich maszynach możemy użyć polecenia cssh.

cssh root@hdp1 root@hdp2 root@hdp3

Jeśli wolimy klasyczne ssh, logujemy się na każdą maszynę oddzielnie:

ssh root@hdp1

UWAGA: Wszystkie dalsze polecenia wykonujemy zalogowani jako użytkownik root

Dostęp do internetu

Żeby instalować dodatkowe pakiety musimy mieć dostęp do internetu. Jeśli nie jest on dostępny, można spróbować włączyć DHCP.

Aby włączyć ręcznie DHCP należy wykonać:

dhclient -v

W celu skonfigurowania tego na stałe warto zmienić wartość (ONBOOT=yes) w pliku /etc/sysconfig/network-scripts/ifcfg-eth0

yum install -y vim
vim /etc/sysconfig/network-scripts/ifcfg-enp0s3

Włączamy logowanie root’a po haśle

Jeśli chcemy umożliwić logowanie użytkownika root po haśle ustawiamy parametr (PermitRootLogin yes) w pliku /etc/ssh/sshd_config

vim /etc/ssh/sshd_config

(UWAGA nigdy tego nie róbmy na produkcyjnych serwerach, NIGDY!)

Logowanie po SSH

ssh-copy-id root@localhost -p 2222
ssh root@localhost -p 2222

Aktualizacja systemu

Żeby pracować na najnowszej wersji systemu należy go zaktualizować

yum -y update
yum -y upgrade

Instalacja epel release

CentOS:

yum install -y epel-release

Red Hat:

cd /tmp
yum install -y wget
wget https://dl.fedoraproject.org/pub/epel/epel-release-latest-7.noarch.rpm
yum install -y epel-release-latest-7.noarch.rpm
yum repolist

Instalacja kolejnych przydatnych narzędzi

yum -y install wget vim htop ntp openssh-server openssh-clients nano bash-completion tree mc byobu ncdu

Zmieniamy hostname (opcjonalnie)

Uwaga, ustawiamy nowe wpisy hostname tylko i wyłącznie wtedy gdy chcemy je zmienić na własne. W wielu przypadkach możemy zostawić obecne hosty o ile są jakieś dostępne.

Na każdej z maszyn ustawiamy inny hostname, na przykład:

hostnamectl set-hostname hdp1.hortonworks.com --static
hostnamectl set-hostname hdp2.hortonworks.com --static
hostnamectl set-hostname hdp3.hortonworks.com --static

jeśli mamy jedną maszynę możemy ustawić:

hostnamectl set-hostname sandbox.hortonworks.com

Status możemy sprawdzić

hostnamectl status
hostname
hostname -f

Polecenie hostname i hostname -f powinny zwracać tą samą wartość.

Konfigurujemy hostów

Żeby maszyny się “widziały” musimy każdej ustawić odpowiedni hostname:

192.168.172.201 hdp1 hdp1.hortonworks.com
192.168.172.202 hdp2 hdp2.hortonworks.com
192.168.172.203 hdp3 hdp3.hortonworks.com

Oczywiście lista zależy od liczby maszyn (w tym przypadku 3) oraz adresach ip które można sprawdzić za pomocą polecenia “ip a”. Trzeba także pamiętać że “swój” hostname dodaliśmy w korku poprzednim, więc musimy go pominąć.

Dla jednego serwera możemy użyć localhost/127.0.0.1:

127.0.0.1   sandbox sandbox.hortonworks.com
127.0.0.1   localhost localhost.localdomain localhost4 localhost4.localdomain4
::1         localhost localhost.localdomain localhost6 localhost6.localdomain6

Konfigurujemy logowanie SSH bez hasła

Na każdej maszynie generujemy zestaw kluczy:

ssh-keygen

Na maszynie hdp1 wyświetlamy sobie klucz publiczny:

cat .ssh/id_rsa.pub

Pobrany klucz maszyny hdp1 wklejamy na każdej maszynie (także hdp1) do pliku:

vim .ssh/authorized_keys

Jeśli wszystko poszło jak trzeba z maszyny hdp1 możemy teraz zalogować się po SSH do każdej innej maszyny:

ssh hdp3

Jeśli instalujemy to na jednej maszynie wystarczy wykonać:

ssh-keygen
ssh-copy-id sandbox.hortonworks.com
ssh sandbox.hortonworks.com

Wyłączamy selinux

Edytujemy plik /etc/sysconfig/selinux ustawiając SELINUX na disabled.

sed -i 's/SELINUX=enforcing/SELINUX=disabled/g' /etc/sysconfig/selinux
sed -i 's/SELINUX=enforcing/SELINUX=disabled/g' /etc/selinux/config

setenforce 0

sestatus

Wyłączamy Firewall’a

systemctl disable firewalld
systemctl stop firewalld
systemctl status firewalld

systemctl disable firewalld.service
systemctl stop firewalld.service
systemctl status firewalld.service

Włączamy serwer czasu NTP

yum install -y ntp

systemctl disable chrony.service

systemctl enable ntpd
systemctl start ntpd
systemctl status ntpd

systemctl enable ntpd.service
systemctl is-enabled ntpd.service
systemctl start ntpd.service
systemctl status ntpd.service

Umask

umask 022
echo umask 022 >> ~/.bash_profile
echo umask 022 >> /etc/profile

Restart maszyn

Teraz warto wykonać restart wszystkich maszyn poleceniem reboot

Instalacja Apache Ambari

UWAGA: Od teraz wszystkie operacje wykonujemy tylko na maszynie hdp1

wget -nv http://public-repo-1.hortonworks.com/ambari/centos7/2.x/updates/2.6.1.3/ambari.repo -O /etc/yum.repos.d/ambari.repo

wget -nv http://public-repo-1.hortonworks.com/HDP/centos7/2.x/updates/2.6.4.0/hdp.repo -O /etc/yum.repos.d/hdp.repo

yum repolist
yum update

Instalujemy Ambari

yum install ambari-server -y

Konfigurujemy Ambari

(W każdym pytaniu wybieramy odpowiedź domyślną klikając klawisz Enter za każdrym razem)

ambari-server setup

W przypadku ambari-server setup upewniamy się, że nie ma żadnych ostrzeżeń, zaś na wszystkie pytania odpowiadamy wartościami domyślnymi klikając enter:

[root@hdp1 ~]# ambari-server setup
Using python  /usr/bin/python
Setup ambari-server
Checking SELinux...
SELinux status is 'disabled'
Customize user account for ambari-server daemon [y/n] (n)? 
Adjusting ambari-server permissions and ownership...
Checking firewall status...
Checking JDK...
[1] Oracle JDK 1.8 + Java Cryptography Extension (JCE) Policy Files 8
[2] Oracle JDK 1.7 + Java Cryptography Extension (JCE) Policy Files 7
[3] Custom JDK
==============================================================================
Enter choice (1): 
To download the Oracle JDK and the Java Cryptography Extension (JCE) Policy Files you must accept the license terms found at http://www.oracle.com/technetwork/java/javase/terms/license/index.html and not accepting will cancel the Ambari Server setup and you must install the JDK and JCE files manually.
Do you accept the Oracle Binary Code License Agreement [y/n] (y)? 
Downloading JDK from http://public-repo-1.hortonworks.com/ARTIFACTS/jdk-8u112-linux-x64.tar.gz to /var/lib/ambari-server/resources/jdk-8u112-linux-x64.tar.gz
jdk-8u112-linux-x64.tar.gz... 100% (174.7 MB of 174.7 MB)
Successfully downloaded JDK distribution to /var/lib/ambari-server/resources/jdk-8u112-linux-x64.tar.gz
Installing JDK to /usr/jdk64/
Successfully installed JDK to /usr/jdk64/
Downloading JCE Policy archive from http://public-repo-1.hortonworks.com/ARTIFACTS/jce_policy-8.zip to /var/lib/ambari-server/resources/jce_policy-8.zip

Successfully downloaded JCE Policy archive to /var/lib/ambari-server/resources/jce_policy-8.zip
Installing JCE policy...
Completing setup...
Configuring database...
Enter advanced database configuration [y/n] (n)? 
Configuring database...
Default properties detected. Using built-in database.
Configuring ambari database...
Checking PostgreSQL...
Running initdb: This may take up to a minute.
Initializing database ... OK


About to start PostgreSQL
Configuring local database...
Configuring PostgreSQL...
Restarting PostgreSQL
Creating schema and user...
done.
Creating tables...
done.
Extracting system views...
ambari-admin-2.5.0.3.7.jar
...........
Adjusting ambari-server permissions and ownership...
Ambari Server 'setup' completed successfully.

Uruchamiamy Ambari

ambari-server start

Konfiguracja klastra HDP

Następnie wchodzimy na adres: http://hdp1:8080 (lub inny wybrany hostname) i całą instalację kontynuujemy w trybie graficznym. Logujemy się jako admin / admin.

Następnie klikamy przycisk Launch Install Wizard

Ustawiamy nazwę naszego klastra

Wybieramy wersję dystrybucji którą chcemy zainstalować

W kolejnym ekranie w polu Target Hosts wskazujemy pełne adresy wybranych maszyn na których chcemy postawić dystrybucję

hdp1.hortonworks.com
hdp2.hortonworks.com
hdp3.hortonworks.com

lub dla jednej maszyny:

sandbox.hortonworks.com

oraz wklejamy zawartość pliku /root/.ssh/id_rsa maszyny na której zainstalowaliśmy Ambari

Po kliknięciu Register and Confirm Ambari przygotowuje nasze maszyny do instalacji

Po zakończonym procesie powinniśmy dostać informację o udanym przygotowaniu maszyn

Jeśli jednak mamy informację o ostrzeżeniach, należy przejrzeć ich listę i rozwiązać problemy

Następnie wybieramy narzędzia które chcemy zainstalować (ilość i rodzaj według uznania, np. HDFS, MapReduce2, Tez, Hive, Pig, HBase, Oozie, Flume, Ambari Metrics)

Wskazujemy na których maszynach mają być zainstalowane usługi zarządzające (Masters) (można zostawić na początek proponowane rozmieszczenie)

oraz usługi robocze (Slaves) (wybieramy wszystkie 3 maszyny dla każdej z usług)

Akceptujemy ostrzeżenia i dostajemy podsumowanie instalacji

Na koniec Ambari zaczyna instalować wszystkie usługi zgodnie z naszymi wytycznymi

Po zakończonej instalacji możemy korzystać już w pełni wdrożonego klastra.

Legenda

CentOS 7 - Instalacja środowiska developerskiego

Sun, 02 Jul 2017 00:00:00 +0000

Jeśli ktoś chciałby pracować na co dzień z systemem CentOS 7 w trybie graficznym, poniżej krótka instrukcja jak to zrobić.

Dodatkowo opis konfiguracji dla VirtualBox’a dla chcącym korzystać tylko na maszynie wirtualnej.

Instalacja systemu

Proces instalacji systemu jest bardzo prosty, wystarczy postępować zgodnie z poleceniami na ekranie, dlatego zostanie pominięty.

Aktualizacja systemu

Żeby pracować na najnowszej wersji systemu należy go zaktualizować

yum -y update
yum -y upgrade

Instalacja środowiska graficznego

Instalacja pakietów i narzędzi

yum -y groups install "GNOME Desktop"

Jeśli chcemy przejrzeć inne grupy możemy wpisać:

yum groups summary

lub

yum group list ids

lub

yum group list

Żeby zobaczyć zawartość grupy należy wpisać w terminalu:

yum group info "GNOME Desktop"

Instalacja przydatnych narzędzi

yum install -y epel-release
yum -y install wget vim htop ntp openssh-server openssh-clients nano bash-completion tree mc byobu ncdu
yum -y install gnome-system-monitor firefox git gedit 
yum -y install gnome-tweak-tool

Dodawanie użytkownika

adduser sages
passwd sages

Restartujemy maszynę

Uruchomienie trybu graficznego

startx

Uruchomienie domyślnie w trybie graficznym

systemctl set-default graphical.target

VirtualBox

Instalacja dodatków dla Virtualbox Guest

yum -y install kernel*
yum -y install gcc kernel-devel kernel-headers dkms make bzip2 perl

Instalacja Dockera i Docker Compose

https://docs.docker.com/install/linux/docker-ce/centos/ https://docs.docker.com/compose/install/#install-compose

Docker bez root’a

Jeśli chcemy by inny użytkownik niż root mógł wykonywać polecenia dockera, należy dać mu uprawnienia sudo do polecenia docker. Należy wtedy dodać wpis do pliku /etc/sudoers:

sages        ALL=(ALL)       NOPASSWD: /usr/bin/docker
sages        ALL=(ALL)       NOPASSWD: /usr/local/bin/docker-compose

warto przy okazji dadać aliasy do pliku ~/.bashrc:

alias docker="sudo /usr/bin/docker"
alias docker-compose="sudo /usr/local/bin/docker-compose"

Instalacja dodatkowych narzędzi

Instalacja MySQL

Aktualnie większość systemów Linux dostarcza domyślnie pakiety dla MariaDB a nie MySQL’a z którego korzysta Ambari, dlatego musimy pobrać najnowszą wersję ze strony: https://dev.mysql.com/downloads/repo/yum/

wget https://dev.mysql.com/get/mysql57-community-release-el7-11.noarch.rpm
rpm -Uvh mysql57-community-release-el7-11.noarch.rpm
yum update

lub

wget https://dev.mysql.com/get/mysql57-community-release-el7-11.noarch.rpm
yum localinstall mysql57-community-release-el7-11.noarch.rpm
yum update

Gdybyśmy mieli problemy możemy skorzystać z

yum clean all
yum clean dbcache
yum clean metadata
yum makecache

Testowy klaster obliczeniowy - Amazon Web Services i CentOS 7

Tue, 20 Jun 2017 12:59:11 +0200

Publiczne chmury obliczeniowe cieszą się coraz większym zainteresowaniem. Jedną z najbardziej popularnych rozwiązań tego typu jest zdecydowanie Amazon Web Services. W poniższym krótkim tutorialu pokażę jak szybko zbudować mini klaster testowy do zastosowań Big Data, na którym będziemy mogli wdrożyć na przykład platformę HDP (instalacji poświęcony został inny tutorial).

Założenie konta

Nasz proces musimy zacząć od założenia konta w serwisie (https://aws.amazon.com/console/) wybierając opcję “Sign in to the Console” a następnie wybranie opcji “I am a new user” i wypełnienie formularza.

Rejestracja jest dość prosta, jedynym utrudnieniem może się okazać konieczność podania karty kredytowej z której będą dokonywane płatności za comiesięczny rachunek około trzeciego dnia następnego miesiąca. Dodatkowo w momencie rejestracji, w celu potwierdzenia karty kredytowej, zostanie pobrana opłata w wysokości jednego dolara.

Planowanie kosztów

Amazon udostępnia możliwość tworzenia maszyn na życzenie (on demand) za które płacimy zgodnie z wykorzystaniem (płatność za godzinę użycia). Aktualny cennik możemy znaleźć pod adresem: https://aws.amazon.com/ec2/pricing/on-demand/. Należy zwrócić uwagę, że ceny zależą od lokalizacji w której będziemy tworzyć maszyny (najtaniej jest w USA, np. Oregon lub Virginia) oraz dostępność wersji maszyn także zależy od kolokacji. Dla przykładu za maszynę m4.xlarge (4 CPU, 16 GB RAM) w Oregon zapłacimy 0.2 $ za godzinę użycia (włącozna maszyna). Dodatkowo naliczane są ceny za wykorzystane powierzchnie dyskowe. Całość naszego wdrożenia, najlepiej sprawdzić za pomocą kalkulatora: https://calculator.s3.amazonaws.com/index.html wybierając w zakładce EC2 odpowiednie maszyny, ich ilość i planowane wykorzystanie przestrzeni dyskowej.

Tworzenie klastra maszyn na AWS

Poniżej kolejne kroki w celu uzyskania kompletnego klastra obliczeniowego na Amazon Web Services.

Całość zaczynamy od wejścia na stronę: https://console.aws.amazon.com/console/ a następnie z menu usług wybieramy “EC2”. Powinniśmy zobaczyć ekran jak niżej:

Na górze widzimy podsumowanie statusu w ramach aktualnie wybranej lokalizacji którą możemy zmienić w prawym górnych rogu (w moim przypadku jest to Virginia w USA).

Jeśli klikniemy menu “Running Instances” zobaczymy listę maszyn dostępnych w tej lokalizacji (w tym przypadku pustą).

Aby stworzyć nowe maszyny klikamy “Launch Instances”. W wyniku dostajemy listę obrazów systemów do załadowania.

W prezentowanej liście brakuje systemu CentOS którego chcemy użyć, dlatego skorzystamy z marketu (AWS Marketplace w menu po lewej) i wbudowanej wyszukiwarki. Wybieramy interesującą nas wersję i klikamy “Select”

Po wybraniu odpowiedniego obrazu otrzymujemy jego podsumowanie. Warto przejrzeć zawarte tam informacje, gdyż możemy się dowiedzieć na przykład jak będzie się nazywał domyślny użytkownik na którego mamy się połączyć po SSH oraz czy obraz jest płatny

Następnie przechodzimy do wybrania typu maszyny. Do naszego klastra testowego skorzystamy z maszyn typu “m4.xlarge” (4 CPU, 16GB RAM)

W kolejnym oknie możemy zdefiniować liczbę maszyn wybranego typu oraz ustawić dodatkowe opcj. Ustawiam 7 maszyn

W następnym oknie definiujemy przestrzeń dyskową dla naszych maszyn. W poniższym przykładzie wybrałem dyski magnetyczne o pojemności 100 GB

Kolejny krok możemy pominąć, umożliwia on dodanie dodatkowych tagów do maszyn

AWS promuje wykorzystanie droższych dysków SSD, więc musimy potwierdzić swój wybór dysków HDD (lub wybrać jednak dyski SSD)

W kolejnym kroku definiujemy konfigurację zabezpieczeń (firewall) poprzez stworzenie nowej grupy. Z racji tworzenia klastra testowego otworzę cały ruch do tych maszyn (uwaga, w żadnym wypadku nie należy tego robić produkcyjnie, gdyż każdy będzie miał dostęp do naszych maszyn i usług na wszystkich portach)

W ostatnim kroku dostajemy podsumowanie naszej stworzonej konfiguracji wraz z ostrzeżeniem że nasza konfiguracja będzie płatna (przez pierwszy rok korzystania z AWS dostajemy tak zwany “free tier” czyli pewien limit użycia za który nie musimy płacić). Klikamy “Launch” by potwierdzić naszą konfigurację.

Domyślny użytkownik systemów na AWS nie ma możliwości logowania się hasłem, dlatego w kolejnym kroku jesteśmy proszeni o stworzenie odpowiedniego klucza który posłuży nam do zalogowania się na niego. Ten klucz musimy zapisać na swoim komputerze oraz nikomu go nie udostępniać.

Ostatecznie tworzą się nasze maszyny

i na koniec dostajemy podsumowanie

Klikając “View Instances” możemy zobaczyć listę naszych maszyn

Legenda

Instalacja dystrybucji Hortonworks Data Platform za pomocą Apache Ambari

Fri, 05 May 2017 19:24:48 +0200

Instrukcja instalacji dystrybucji Hortonworks Data Platform HDP-2.6.3.0 na maszynach z systemem Red Hat 6.9 lub CentOS 6.9. Do instalacji zostanie użyte Apache Ambari w wersji 2.5.1.0.

Klaster ssh

Jeśli chcemy wykonywać wybrane polecenia jednocześnie na wszystkich maszynach możemy użyć polecenia cssh.

cssh root@hdp1 root@hdp2 root@hdp3

Jeśli wolimy klasyczne ssh, logujemy się na każdą maszynę oddzielnie:

ssh root@hdp1

UWAGA: Wszystkie dalesze polecenia wykonujemy zalogowani jako użytkownik root

Aktualizacja systemu

yum update -y

Instalacja przydatnych narzędzi

yum install -y wget

Instalacja epel release

CentOS:

yum install -y epel-release

Red Hat:

cd /tmp
wget https://dl.fedoraproject.org/pub/epel/epel-release-latest-6.noarch.rpm
yum install -y epel-release-latest-6.noarch.rpm
yum repolist

Instalacja kolejnych przydatnych narzędzi

yum -y install wget vim htop ntp openssh-server openssh-clients nano bash-completion tree

Zmieniamy hostname (opcjonalnie)

Ten krok wykonujemy jeśli chcemy zmienić hostname w systemie.

Obecny hostname możemy sprawdzić za pomocą:

hostname
hostname -f
# lub hostname --fqdn

Pierwsze polecenie pokazuje krótszą wartość, drugie pełną nazwę.

W celu zmiany edytujemy plik:

vim /etc/sysconfig/network

Zmieniamy wartość linijki (odpowiednio na każdej maszynie):

HOSTNAME=hdp1.hortonworks.com

Pdobnie wpisujemy “swój” hostname w pliku /etc/hosts

vim /etc/hosts

na odpowiednią wartość:

127.0.0.1 hdp1 hdp1.hortonworks.com

Na koniec wykonujemy:

/etc/init.d/network restart

lub najlepiej restart całego systemu :)

Konfigurujemy hostów

Żeby maszyny się “widziały” musimy każdej ustawić odpowiedni hostname:

192.168.172.201 hdp1 hdp1.hortonworks.com
192.168.172.202 hdp2 hdp2.hortonworks.com
192.168.172.203 hdp3 hdp3.hortonworks.com

Konfigurujemy logowanie SSH bez hasła

Na każdem maszynie generujemy zestaw kluczy:

ssh-keygen

Na maszynie hdp1 wyświetlamy sobie klucz publiczny:

cat .ssh/id_rsa.pub

Pobrany klucz maszyny hdp1 wklejami na każdej maszynie (także hdp1) do pliku:

vim .ssh/authorized_keys

Jeśli wszystko poszło jak trzeba z maszyny hdp1 możemy teraz zalogować się po SSH do każdej innej maszyny:

ssh hdp3

Wyłączamy selinux

Edytujemy plik /etc/sysconfig/selinux ustawiając SELINUX na disabled.

sed -i 's/SELINUX=enforcing/SELINUX=disabled/g' /etc/sysconfig/selinux
sed -i 's/SELINUX=enforcing/SELINUX=disabled/g' /etc/selinux/config

sestatus

Wyłączamy Firewall’a

service iptables stop
/etc/init.d/iptables stop
chkconfig iptables off

Włączamy serwer czasu NTP

yum install -y ntp
chkconfig ntpd on

Umask

echo umask 022 >> ~/.bash_profile
echo umask 022 >> /etc/profile

Restart maszyn

Teraz warto wykonać restart wszystkich maszyn poleceniem reboot

Instalacja Apache Ambari

UWAGA: Od teraz wszystkie operacje wykonujemy tylko na maszynie hdp1

wget -nv http://public-repo-1.hortonworks.com/ambari/centos6/2.x/updates/2.5.1.0/ambari.repo -O /etc/yum.repos.d/ambari.repo
yum install ambari-server -y
ambari-server setup

W przypadku ambari-server setup upewniamy się, że nie ma żadnych ostrzeżeń, zaś na wszystkie pytania odpowiadamy wartościami domyślnymi klikając enter:

[root@hdp1 ~]# ambari-server setup
Using python  /usr/bin/python
Setup ambari-server
Checking SELinux...
SELinux status is 'disabled'
Customize user account for ambari-server daemon [y/n] (n)? 
Adjusting ambari-server permissions and ownership...
Checking firewall status...
Checking JDK...
[1] Oracle JDK 1.8 + Java Cryptography Extension (JCE) Policy Files 8
[2] Oracle JDK 1.7 + Java Cryptography Extension (JCE) Policy Files 7
[3] Custom JDK
==============================================================================
Enter choice (1): 
To download the Oracle JDK and the Java Cryptography Extension (JCE) Policy Files you must accept the license terms found at http://www.oracle.com/technetwork/java/javase/terms/license/index.html and not accepting will cancel the Ambari Server setup and you must install the JDK and JCE files manually.
Do you accept the Oracle Binary Code License Agreement [y/n] (y)? 
Downloading JDK from http://public-repo-1.hortonworks.com/ARTIFACTS/jdk-8u112-linux-x64.tar.gz to /var/lib/ambari-server/resources/jdk-8u112-linux-x64.tar.gz
jdk-8u112-linux-x64.tar.gz... 100% (174.7 MB of 174.7 MB)
Successfully downloaded JDK distribution to /var/lib/ambari-server/resources/jdk-8u112-linux-x64.tar.gz
Installing JDK to /usr/jdk64/
Successfully installed JDK to /usr/jdk64/
Downloading JCE Policy archive from http://public-repo-1.hortonworks.com/ARTIFACTS/jce_policy-8.zip to /var/lib/ambari-server/resources/jce_policy-8.zip

Successfully downloaded JCE Policy archive to /var/lib/ambari-server/resources/jce_policy-8.zip
Installing JCE policy...
Completing setup...
Configuring database...
Enter advanced database configuration [y/n] (n)? 
Configuring database...
Default properties detected. Using built-in database.
Configuring ambari database...
Checking PostgreSQL...
Running initdb: This may take up to a minute.
Initializing database ... OK


About to start PostgreSQL
Configuring local database...
Configuring PostgreSQL...
Restarting PostgreSQL
Creating schema and user...
done.
Creating tables...
done.
Extracting system views...
ambari-admin-2.5.0.3.7.jar
...........
Adjusting ambari-server permissions and ownership...
Ambari Server 'setup' completed successfully.

Uruchamiamy Ambari

ambari-server start

Konfiguracja klastra HDP

Następnie wchodzimy na adres: http://hdp1:8080 i całą instalację kontynuujemy w trybie graficznym. Logujemy się jako admin / admin.

Następnie klikamy przycisk Launch Install Wizard

Ustawiamy nazwę naszego klastra

Wybieramy wersję dystrybucji którą chcemy zainstalować

W kolejnym ekranie w polu Target Hosts wskazujemy pełne adresy wybranych maszyn na których chcemy postawić dystrybucję

hdp1.hortonworks.com
hdp2.hortonworks.com
hdp3.hortonworks.com

oraz wklejamy zawartość pliku /root/.ssh/id_rsa maszyny na której zainstalowaliśmy Ambari

Po kliknięciu Register and Confirm Ambari przygotowuje nasze maszyny do instalacji

Po zakończonym procesie powinniśmy dostać informację o udanym przygotowaniu maszyn

Jeśli jednak mamy informację o ostrzeżeniach, należy przejrzeć ich listę i rozwiązać problemy

Następnie wybieramy narzędzia które chcemy zainstalować (ilość i rodzaj według uznania, np. HDFS, MapReduce2, Tez, Hive, Pig, HBase, Oozie, Flume, Ambari Metrics)

Wskazujemy na których maszynach mają być zainstalowane usługi zarządzające (Masters) (można zostawić na początek proponowane rozmieszczenie)

oraz usługi robocze (Slaves) (wybieramy wszystkie 3 maszyny dla każdej z usług)

Akceptujemy ostrzeżenia i dostajemy podsumowanie instalacji

Na koniec Ambari zaczyna instalować wszystkie usługi zgodnie z naszymi wytycznymi

Po zakończonej instalacji możemy korzystać już w pełni wdrożonego klastra.

Legenda

Testowy klaster obliczeniowy - VirtualBox 5 i CentOS 7

Thu, 04 May 2017 12:59:11 +0200

VirtualBox jest darmowym narzędziem firmy Oracle (poprzednio Sun Microsystems) pozwaląjącym na łatwą i wygodną wirtualizację na własnym komputerze. W bardzo szybki sposób jesteśmy w stanie stworzyć z jego pomocą klaster kilku maszyn i z powodzeniem używać go do testów.

Instalacja VirtualBox’a

VirtualBox’a można zainstalować na systemie Windows, Linux, MacOS i Solaris ściągając instalator ze strony projektu https://www.virtualbox.org/. Użytkownicy systemów Linux mogą go też łatwo i szybko zainstalować za pomocą repozytoriów (zalecane dla początkujących użytkowników).

Po zainstalowaniu możemy uruchomić narzędzie w trybie graficznym lub korzystać z linii komend. Ta druga opcja udostępnia większe możliwości, jednak jest adresowana do bardziej doświadczonych użytkowników, dlatego skorzystamy z wersji okienkowej.

Po uruchomieniu wersji graficznej powinniśmy zobaczyć coś takiego:

Stworzenie maszyny w VirtualBox

Teraz tworzymy nową czystą maszynę klikając New.

W nowo otwartym oknie wpisujemy nazwę, np. hadoop1, wybieramy Typ Linux i wersję Red Hat (64-bit) (CentOS jest oparty o dystrubucję Red Hat Enterprise Linux).

W kolejnym ekranie przydzielamy pamięć RAM do maszyny, np. 16 GB.

Tworzymy nowy wirtualny dysk dla naszej maszyny wirtualnej.

Wybieramy domyślny typ dysku VDI.

Ustawiamy dynamiczne alokowanie powierzchni dysku (nasz wirtualny dysk będzie miał od razu widoczną całkowitą powierzchnię, ale fizycznie plik na dysku komputera hosta na którym zainstalowany jest VirtualBox będzie miał wielkość proporcjonalną do wielkości zajmowanego miejsca na wirtualnym dysku).

Ustawiamy docelową wielkość dysku (z racji dynamicznej alokacji możemy ustawić więcej niż potrzebujemy, np. 100 GB) i klimay Create.

Nasza maszyna jest już utworzona i widzimy ją na liście.

Pobranie CentOS’a

Najnowszą siądmą wersję systemu CentOS (Community ENTerprise Operating System) można pobrać z https://www.centos.org/download/. Wybieramy wersję minimal ISO, resztę pobierzemy przez sieć http://isoredirect.centos.org/centos/7/isos/x86_64/CentOS-7-x86_64-Minimal-1611.iso. Najszybciej będzie ściągnąć iso z serwerów ICM’u lub AGH.

Instalacja CentOS’a

Uruchamiamy utworzoną maszynę wirtualną przyciskiem Run. Następnie wybieramy wcześniej ściągnięty obraz ISO systemu CentOS (klikamy ikonkę katalogu obok wybieranej listy)

Po uruchomieniu maszyny z obrazu ISO wybieramy instalację.

Możemy ustawić język polski dla zgodności z polskimi stronami kodowymi.

Instalator będzie nas prosić o potwierdzenie automatycznego partycjonowania całego dysku.

Podczas instalacji systemu konieczne jest ustawienie hasła dla użytkownika root.

Gdy system skończy się instalować uruchamiamy ponownie maszynę (Virtualbox uruchomi ją już automatycznie z dysku wirtualnego a nie z wskazanego obrazu ISO)

Po uruchomieniu maszyny możemy zalogować się do niej na użytkownika root wpisując go jako login i podając wcześniej ustawione hasło.

Konfiguracja sieci

Dla wyłączonej maszyny w VirtualBox w zakładce Sieć ustawiamy Mostkowana karta sieciowa (bridge).

Następnie konfigurujemy stałe IP jedną z dwóch metod: Konfiguracja sieci w systemie CentOS 7

Dodatkowe maszyny

Jeśli chcemy mieć więcej maszyn możemy ten proces powtórzyć mogąc jednocześnie wybrać inne opcje konfiguracyjne lub po prostu gdy chcemy mieć identyczne maszyny sklonować już stworzoną maszynę. W tym celu klikamy prawym przyciskiem myszy na wybranej maszynie i wybieramy opcję klonowania (Ctrl+O)

Warto przy tym wybrać opcję stworzenia innego numeru MAC adresu karty sieciowej:

oraz wybrać pełną kopię

W przypadku dodatkowego pytania o klonowanie snapshotów, możemy je pominąć i wybrać tylko aktualny stan

W ten sposób otrzymaliśmy gotowy klaster testowy i możemy zainstalować na nim Hadoopa lub całą wybraną jego dystrybucję czemu poświęcone będą kolejne wpisy.

Legenda

Konfiguracja sieci w systemie CentOS / RedHat 8

Sun, 02 Apr 2017 21:34:44 +0200

Trzy sposoby konfiguracji sieci w systemie CentOS 7.

Dynamiczne IP za pomocą DHCP

Sprawdzamy interfejsy sieciowe i urządzenia

ip l

Łączymy się z siecią za pomocą DHCP i interfejsem enp03

dhclient -v enp0s3

Autostart DHCP wraz z systemem operacyjnym

W pliku /etc/sysconfig/network-scripts/ifcfg-enp0s3 zmieniamy ONBOOT na “yes”. W powyższym przykładzie “enp0s3” to nazwa naszego urządzenia z listy zwróconej przez “ip l”

Statyczne IP ustawiane ręcznie

Wyłączamy NetworkManager’a

systemctl disable NetworkManager.service
systemctl stop NetworkManager.service

Ręcznie dodajemy następujące wpisy do pliku /etc/sysconfig/network-scripts/ifcfg-enp0s3

BOOTPROTO="static"
ONBOOT="yes"
IPADDR=192.168.172.186
NETMASK=255.255.255.0
GATEWAY=192.168.172.1
DNS1=8.8.8.8

Ewentualnie można zamiast edytora vi użyć sed’a:

sed -i 's/ONBOOT=no/ONBOOT=yes/g'  /etc/sysconfig/network-scripts/ifcfg-enp0s3
sed -i 's/BOOTPROTO=dhcp/BOOTPROTO=static/g'  /etc/sysconfig/network-scripts/ifcfg-enp0s3

Restartujemy serwis sieciowy

systemctl restart network.service

Statyczne IP ustawiane za pomocą Network Manageraip

Zanim zaczniemy używać narzędzia nmtui, musimy ustawić “NM_CONTROLLED=yes” w pliku /etc/sysconfig/network-scripts/ifcfg-enp0s3.

vi /etc/sysconfig/network-scripts/ifcfg-enp0s3

Edytujemy ustawienia urządzeni enp0s3

nmtui edit enp0s3

Ustawiamy statyczny adres IP

192.168.172.186/24

oraz zaznaczamy opcje:

Wymagane adresowanie IPv4 dla tego połączenia
Łączenie automatyczne

Restartujemy serwis sieciowy

systemctl restart network.service

Witaj świecie

Sat, 01 Apr 2017 00:00:00 +0000

Big Data Passion to strona dla pasjonatów szeroko rozumianego Big Data. Treści prezentowane na stronie będą dotyczyć takich tematów jak:

Języki programowania (Java, Scala, Kotlin, Groovy, Python, Ruby, SQL, Bash etc.)
Przetwarzanie danych (Spark, MapReduce, Tez, Apex, Hive, Pig, Impala etc.)
Strumieniowe przetwarzanie i składowanie danych (Kafka, ActiveMQ, Flume, NiFi, MiNiFi, Logstash, Spark Streaming, Flink, Storm etc.)
Analizę danych, Data Science, NLP, Machine Learning, Sztuczną Inteligencję (Mahout, Spark MLlib, MXNet, Tensorflow etc.)
NoSQL i składowanie danych (HDFS, HBase, Cassandra, Mongo, Redis, Hazelcast, Kudu, Druid etc.)
Programowanie asynchroniczne (Vert.x, Netty, NodeJS etc.)
Biblioteki i narzędzia (Akka, Spring framework, Spring Data, Spring Integration, Spring XD etc.)
Wyszukiwanie danych (Lucene, Solr, Elasticsearch etc.)
Business Intelligence (Kylin, Pentaho, Mondrian, Kettle etc.)
Wizualizacja i prezentacja danych (Zeppelin, Jupyter, Kibana, Superset, Hue etc.)
Dystrybucje Big Data (Hortonworks, Cloudera, MapR, BigTop etc.)
Chmury obliczeniowe (Amazon Web Services, Microsoft Azure, Google Cloud Platform, Oracle Cloud, Databricks Cloud, Confluent Cloud, Oktawave etc.)
Administrowanie i zarządzanie rozproszonymi klastrami obliczeniowymi, usługami i procesami (DevOps, Docker, Kubernetes, Ansible, Jenkins, Oozie, Airflow etc.)

Mon, 01 Jan 0001 00:00:00 +0000

Java wyzwania program: http://kodolamacz.pl/kurs-java/

Wyzwania programistyczne (poniedziałki):

Wstęp do programowania funkcyjnego, , klasy wewnętrzne, adnotacje,
Operacje matematyczne, na tekstach i na datach (local date)

Tematy dodatkowe (piątki):

książki które należy przeczytać
jak się uczyć programować, najlepsze źródła i książki
Poznaj lepiej swoje IDE
Kariera programisty, czyli jak to wygląda naprawdę
Dobre techniki, wzorce, clean code itd itp
Java effective programming
Proces tworzenia oprogramowania, ci, CD, agile, itd itp
Git i inne repozytoria
Co dalej po wyzwaniach?
kariera developera
model pamięci w JVM

TODO:

- złożoność cyklomatyczna
String + char
rzutowanie
więcej o pętlach…

Tutorial Oracle: